@nicolastoulemont/std 0.4.0 → 0.5.1

package/dist/result-DhYA-J-M.mjs

@@ -1,542 +0,0 @@
-import { t as FxTypeId } from "./fx.types-DpIQILok.mjs";
-import { n as dual, t as pipeMethod } from "./pipeable-DYNrUps7.mjs";
-import { n as isPromise } from "./flow-D4cE0EAg.mjs";
-
-//#region src/result/result.ts
-/**
-* Create a successful Result.
-*
-* @param value - The success value
-* @returns A Result with ok: true
-*
-* @example
-* ```ts
-* ok(42) // { ok: true, value: 42 }
-* ```
-*/
-const ok = (value) => {
-	return {
-		ok: true,
-		value,
-		pipe: pipeMethod,
-		[FxTypeId]: {
-			_A: () => value,
-			_E: () => void 0,
-			_R: () => void 0
-		},
-		*[Symbol.iterator]() {
-			return value;
-		}
-	};
-};
-/**
-* Create an error Result.
-*
-* @param error - The error value
-* @returns A Result with ok: false
-*
-* @example
-* ```ts
-* err('something went wrong') // { ok: false, error: 'something went wrong' }
-* ```
-*/
-const err = (error) => {
-	const result = {
-		ok: false,
-		error,
-		pipe: pipeMethod,
-		[FxTypeId]: {
-			_A: () => void 0,
-			_E: () => error,
-			_R: () => void 0
-		},
-		*[Symbol.iterator]() {
-			yield result;
-			throw new Error("Unreachable: Do should short-circuit on error");
-		}
-	};
-	return result;
-};
-/**
-* Check if a Result is successful.
-*
-* @param result - The Result to check
-* @returns true if the Result is ok
-*
-* @example
-* ```ts
-* const result = ok(42)
-* if (isOk(result)) {
-*   console.log(result.value) // TypeScript knows value exists
-* }
-* ```
-*/
-const isOk = (result) => result.ok;
-/**
-* Check if a Result is an error.
-*
-* @param result - The Result to check
-* @returns true if the Result is an error
-*
-* @example
-* ```ts
-* const result = err('oops')
-* if (isErr(result)) {
-*   console.log(result.error) // TypeScript knows error exists
-* }
-* ```
-*/
-const isErr = (result) => !result.ok;
-/**
-* Transform the success value of a Result.
-* If the Result is an error, it passes through unchanged.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `map(result, fn)`
-* - Data-last: `pipe(result, map(fn))`
-*
-* Supports both sync and async functions:
-* - Sync fn: returns Result<U, E>
-* - Async fn: returns Promise<Result<U, E>>
-*
-* @param fn - Function to transform the success value
-* @returns A function that takes a Result and returns a new Result
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* map(ok(5), n => n * 2) // { ok: true, value: 10 }
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   ok(5),
-*   map(n => n * 2)
-* ) // { ok: true, value: 10 }
-*
-* // Async usage
-* await pipe(
-*   ok(userId),
-*   map(async id => await fetchName(id))
-* ) // Promise<Result<string, E>>
-* ```
-*/
-const map = dual(2, (result, fn) => {
-	if (!result.ok) return result;
-	const mapped = fn(result.value);
-	if (mapped instanceof Promise) return mapped.then(ok);
-	return ok(mapped);
-});
-/**
-* Transform the error value of a Result.
-* If the Result is successful, it passes through unchanged.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `mapErr(result, fn)`
-* - Data-last: `pipe(result, mapErr(fn))`
-*
-* Supports both sync and async functions:
-* - Sync fn: returns Result<T, F>
-* - Async fn: returns Promise<Result<T, F>>
-*
-* @param fn - Function to transform the error value
-* @returns A function that takes a Result and returns a new Result
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* mapErr(err({ code: 404 }), e => `Error: ${e.code}`)
-* // { ok: false, error: 'Error: 404' }
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   err({ code: 404 }),
-*   mapErr(e => `Error: ${e.code}`)
-* ) // { ok: false, error: 'Error: 404' }
-*
-* // Async usage
-* await pipe(
-*   err(errorCode),
-*   mapErr(async code => await translateError(code))
-* ) // Promise<Result<T, string>>
-* ```
-*/
-const mapErr = dual(2, (result, fn) => {
-	if (result.ok) return result;
-	const mapped = fn(result.error);
-	if (mapped instanceof Promise) return mapped.then(err);
-	return err(mapped);
-});
-/**
-* Chain operations that return Results.
-* If the Result is an error, it passes through unchanged.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `flatMap(result, fn)`
-* - Data-last: `pipe(result, flatMap(fn))`
-*
-* Supports both sync and async functions:
-* - Sync fn: returns Result<U, E | E2>
-* - Async fn: returns Promise<Result<U, E | E2>>
-*
-* @param fn - Function that takes a value and returns a Result (or Promise<Result>)
-* @returns A function that takes a Result and returns a new Result
-*
-* @example
-* ```ts
-* const divide = (a: number, b: number) =>
-*   b === 0 ? err('division by zero') : ok(a / b)
-*
-* // Data-first (direct call)
-* flatMap(ok(10), n => divide(n, 2)) // { ok: true, value: 5 }
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   ok(10),
-*   flatMap(n => divide(n, 2))
-* ) // { ok: true, value: 5 }
-*
-* // Async usage
-* await pipe(
-*   ok(userId),
-*   flatMap(async id => ok(await fetchUser(id)))
-* ) // Promise<Result<User, E>>
-* ```
-*/
-const flatMap = dual(2, (result, fn) => result.ok ? fn(result.value) : result);
-/**
-* Perform a side effect on the success value without modifying the Result.
-* Useful for debugging, logging, or other side effects in a pipeline.
-* If the Result is an error, the function is not called.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `tap(result, fn)`
-* - Data-last: `pipe(result, tap(fn))`
-*
-* Supports both sync and async functions:
-* - Sync fn: returns Result<T, E>
-* - Async fn: returns Promise<Result<T, E>>
-*
-* @param fn - Function to call with the success value (return value is ignored)
-* @returns A function that takes a Result and returns the same Result
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* tap(ok(42), console.log) // logs 42, returns { ok: true, value: 42 }
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   ok(42),
-*   tap(console.log),  // logs 42
-*   map(n => n * 2)
-* ) // { ok: true, value: 84 }
-*
-* // Async usage
-* await pipe(
-*   ok(42),
-*   tap(async v => await logToServer(v)),
-*   map(n => n * 2)
-* ) // Promise<Result<84, E>>
-* ```
-*/
-const tap = dual(2, (result, fn) => {
-	if (!result.ok) return result;
-	const sideEffect = fn(result.value);
-	if (sideEffect instanceof Promise) return sideEffect.then(() => result);
-	return result;
-});
-/**
-* Recover from an error by providing an alternative Result.
-* If the Result is successful, it passes through unchanged.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `orElse(result, fn)`
-* - Data-last: `pipe(result, orElse(fn))`
-*
-* Supports both sync and async functions:
-* - Sync fn: returns Result<T | U, E2>
-* - Async fn: returns Promise<Result<T | U, E2>>
-*
-* @param fn - Function that takes the error and returns an alternative Result
-* @returns A function that takes a Result and returns a new Result
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* orElse(err('cache miss'), () => ok(defaultValue))
-* // { ok: true, value: defaultValue }
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   err('cache miss'),
-*   orElse(() => ok(defaultValue))
-* ) // { ok: true, value: defaultValue }
-*
-* // Async recovery
-* await pipe(
-*   err('cache miss'),
-*   orElse(async () => ok(await fetchFromAPI()))
-* ) // Promise<Result<T, E2>>
-*
-* // Chain multiple fallbacks
-* pipe(
-*   err('not found'),
-*   orElse(() => tryCache()),
-*   orElse(() => tryAPI()),
-*   orElse(() => ok(fallback))
-* )
-* ```
-*/
-const orElse = dual(2, (result, fn) => result.ok ? result : fn(result.error));
-/**
-* Filter a successful Result based on a predicate.
-* If the predicate returns false, converts the success to an error.
-* If the Result is already an error, it passes through unchanged.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `filter(result, predicate, onFail)`
-* - Data-last: `pipe(result, filter(predicate, onFail))`
-*
-* @param predicate - Function that returns true to keep the value
-* @param onFail - Function that creates the error when predicate fails
-* @returns A function that takes a Result and returns a new Result
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* filter(ok(5), n => n > 10, n => `${n} is too small`)
-* // { ok: false, error: '5 is too small' }
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   ok(5),
-*   filter(n => n > 10, n => `${n} is too small`)
-* ) // { ok: false, error: '5 is too small' }
-*
-* pipe(
-*   ok(15),
-*   filter(n => n > 10, n => `${n} is too small`)
-* ) // { ok: true, value: 15 }
-*
-* // With complex validation
-* pipe(
-*   ok(user),
-*   filter(u => u.age >= 18, u => ({ code: 'UNDERAGE', user: u }))
-* )
-* ```
-*/
-const filter = dual(3, (result, predicate, onFail) => {
-	if (!result.ok) return result;
-	return predicate(result.value) ? result : err(onFail(result.value));
-});
-/**
-* Combine multiple Results into a single Result.
-* Supports both array and object inputs.
-*
-* - If all Results are ok, returns ok with all values
-* - If any Result is an error, returns the first error (short-circuits)
-*
-* For arrays of 1-6 elements, tuple types are inferred automatically.
-* For longer arrays, use `as const` to preserve tuple structure.
-*
-* @example
-* ```ts
-* // Array form - tuple types inferred automatically for up to 6 elements
-* const [num, str] = pipe(
-*   Result.all([parseNumber(input), parseString(other)]),
-*   Result.unwrapOr([0, ''])
-* )
-*
-* // Object form - returns Result<{ user: User, config: Config }, E>
-* pipe(
-*   Result.all({ user: fetchUser(id), config: loadConfig() }),
-*   Result.tap(({ user, config }) => console.log(user.name, config.theme))
-* )
-* ```
-*/
-const all = (results) => {
-	if (Array.isArray(results)) {
-		const values$1 = [];
-		for (const result of results) {
-			if (!result.ok) return result;
-			values$1.push(result.value);
-		}
-		return ok(values$1);
-	}
-	const values = {};
-	for (const [key, result] of Object.entries(results)) {
-		const r = result;
-		if (!r.ok) return result;
-		values[key] = r.value;
-	}
-	return ok(values);
-};
-/**
-* Get the success value or a default value.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `unwrapOr(result, defaultValue)`
-* - Data-last: `pipe(result, unwrapOr(defaultValue))`
-*
-* Uses NoInfer to prevent type inference from the default value.
-*
-* @param defaultValue - Value to return if the Result is an error
-* @returns A function that takes a Result and returns the value or default
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* unwrapOr(ok(42), 0) // 42
-* unwrapOr(err('oops'), 0) // 0
-*
-* // Data-last (curried for pipe)
-* pipe(ok(42), unwrapOr(0)) // 42
-* pipe(err('oops'), unwrapOr(0)) // 0
-* ```
-*/
-const unwrapOr = dual(2, (result, defaultValue) => result.ok ? result.value : defaultValue);
-/**
-* Get the success value or compute a value from the error.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `unwrapOrElse(result, fn)`
-* - Data-last: `pipe(result, unwrapOrElse(fn))`
-*
-* @param fn - Function to compute a value from the error
-* @returns A function that takes a Result and returns the value or computed value
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* unwrapOrElse(err({ code: 404 }), e => `Error ${e.code}`) // 'Error 404'
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   err({ code: 404 }),
-*   unwrapOrElse(e => `Error ${e.code}`)
-* ) // 'Error 404'
-* ```
-*/
-const unwrapOrElse = dual(2, (result, fn) => result.ok ? result.value : fn(result.error));
-/**
-* Pattern match on a Result, handling both success and error cases.
-*
-* Supports both data-first and data-last calling styles:
-* - Data-first: `match(result, { ok: ..., err: ... })`
-* - Data-last: `pipe(result, match({ ok: ..., err: ... }))`
-*
-* @param handlers - Object with ok and err handlers
-* @returns A function that takes a Result and returns the handler result
-*
-* @example
-* ```ts
-* // Data-first (direct call)
-* match(ok(42), {
-*   ok: n => `Got ${n}`,
-*   err: e => `Error: ${e}`
-* }) // 'Got 42'
-*
-* // Data-last (curried for pipe)
-* pipe(
-*   ok(42),
-*   match({
-*     ok: n => `Got ${n}`,
-*     err: e => `Error: ${e}`
-*   })
-* ) // 'Got 42'
-* ```
-*/
-const match = dual(2, (result, handlers) => result.ok ? handlers.ok(result.value) : handlers.err(result.error));
-/**
-* Wrap a function that might throw into a Result.
-* Supports both sync and async functions with automatic type inference.
-*
-* - Sync fn: returns Result<T, Error>
-* - Async fn: returns Promise<Result<T, Error>>
-*
-* **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),
-* you should add an explicit return type annotation. This is because TypeScript's
-* conditional types cannot determine if `any` is a Promise or not, resulting in a
-* union type `Promise<Result<unknown, Error>> | Result<any, Error>` that won't work
-* with Result utilities like `isOk` or `isErr`.
-*
-* @param fn - Function that might throw (sync or async)
-* @returns A Result with the return value or the caught error
-*
-* @example
-* ```ts
-* // Sync usage
-* fromTry(() => JSON.parse('{"valid": true}'))
-* // { ok: true, value: { valid: true } }
-*
-* fromTry(() => JSON.parse('not json'))
-* // { ok: false, error: SyntaxError }
-*
-* // When fn returns `any`, add explicit return type:
-* fromTry((): unknown => JSON.parse(input))
-* fromTry((): MyType => JSON.parse(input))
-*
-* // Async usage
-* await fromTry(async () => await fetch('/api/user'))
-* // Promise<Result<Response, Error>>
-*
-* await fromTry(async () => {
-*   throw new Error('network error')
-* })
-* // Promise<{ ok: false, error: Error }>
-* ```
-*/
-const fromTry = (fn) => {
-	try {
-		const result = fn();
-		if (isPromise(result)) return result.then(ok).catch((e) => err(e instanceof Error ? e : new Error(String(e))));
-		return ok(result);
-	} catch (e) {
-		return err(e instanceof Error ? e : new Error(String(e)));
-	}
-};
-/**
-* Result namespace containing all utility functions for working with Result types.
-*
-* Result represents either success (ok) or failure (err). Use this for operations
-* that can fail with typed errors.
-*
-* @see {@link Option} for presence/absence semantics (no error information)
-* @see {@link Either} for two valid outcomes (not just success/failure)
-*
-* @example
-* ```ts
-* import { Result, pipe } from '@repo/std'
-* import type { Result as ResultType } from '@repo/std'
-*
-* const divide = (a: number, b: number): ResultType<number, string> =>
-*   b === 0 ? Result.err('division by zero') : Result.ok(a / b)
-*
-* const result = pipe(
-*   divide(10, 2),
-*   Result.map(n => n * 2),
-*   Result.unwrapOr(0)
-* )
-* ```
-*/
-const Result = {
-	ok,
-	err,
-	isOk,
-	isErr,
-	map,
-	mapErr,
-	flatMap,
-	tap,
-	orElse,
-	filter,
-	all,
-	unwrapOr,
-	unwrapOrElse,
-	match,
-	fromTry
-};
-
-//#endregion
-export { flatMap as a, isOk as c, match as d, ok as f, unwrapOrElse as g, unwrapOr as h, filter as i, map as l, tap as m, all as n, fromTry as o, orElse as p, err as r, isErr as s, Result as t, mapErr as u };
-//# sourceMappingURL=result-DhYA-J-M.mjs.map

package/dist/result-DhYA-J-M.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-DhYA-J-M.mjs","names":["values"],"sources":["../src/result/result.ts"],"sourcesContent":["import { FxTypeId } from \"../fx/fx.types\"\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { pipeMethod } from \"../shared/pipeable\"\nimport type {\n  FromTryReturn,\n  Result as ResultType,\n  ResultAll,\n  ResultFlatMap,\n  ResultMap,\n  ResultMapErr,\n  ResultMatch,\n  ResultTap,\n  ResultOrElse,\n  ResultFilter,\n  ResultUnwrapOr,\n  ResultUnwrapOrElse,\n} from \"./result.types\"\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create a successful Result.\n *\n * @param value - The success value\n * @returns A Result with ok: true\n *\n * @example\n * ```ts\n * ok(42) // { ok: true, value: 42 }\n * ```\n */\nexport const ok = <T>(value: T): ResultType<T, never> => {\n  const result: ResultType<T, never> = {\n    ok: true,\n    value,\n    pipe: pipeMethod,\n    [FxTypeId]: {\n      _A: () => value,\n      _E: () => undefined as never,\n      _R: () => undefined as never,\n    },\n    // oxlint-disable-next-line require-yield\n    *[Symbol.iterator](): Generator<ResultType<T, never>, T, unknown> {\n      return value\n    },\n  }\n  return result\n}\n\n/**\n * Create an error Result.\n *\n * @param error - The error value\n * @returns A Result with ok: false\n *\n * @example\n * ```ts\n * err('something went wrong') // { ok: false, error: 'something went wrong' }\n * ```\n */\nexport const err = <E>(error: E): ResultType<never, E> => {\n  const result: ResultType<never, E> = {\n    ok: false,\n    error,\n    pipe: pipeMethod,\n    [FxTypeId]: {\n      _A: () => undefined as never,\n      _E: () => error,\n      _R: () => undefined as never,\n    },\n    *[Symbol.iterator](): Generator<ResultType<never, E>, never, unknown> {\n      yield result\n      throw new Error(\"Unreachable: Do should short-circuit on error\")\n    },\n  }\n  return result\n}\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if a Result is successful.\n *\n * @param result - The Result to check\n * @returns true if the Result is ok\n *\n * @example\n * ```ts\n * const result = ok(42)\n * if (isOk(result)) {\n *   console.log(result.value) // TypeScript knows value exists\n * }\n * ```\n */\nexport const isOk = <T, E>(result: ResultType<T, E>): result is Extract<ResultType<T, E>, { ok: true }> => result.ok\n\n/**\n * Check if a Result is an error.\n *\n * @param result - The Result to check\n * @returns true if the Result is an error\n *\n * @example\n * ```ts\n * const result = err('oops')\n * if (isErr(result)) {\n *   console.log(result.error) // TypeScript knows error exists\n * }\n * ```\n */\nexport const isErr = <T, E>(result: ResultType<T, E>): result is Extract<ResultType<T, E>, { ok: false }> => !result.ok\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the success value of a Result.\n * If the Result is an error, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(result, fn)`\n * - Data-last: `pipe(result, map(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Result<U, E>\n * - Async fn: returns Promise<Result<U, E>>\n *\n * @param fn - Function to transform the success value\n * @returns A function that takes a Result and returns a new Result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * map(ok(5), n => n * 2) // { ok: true, value: 10 }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   ok(5),\n *   map(n => n * 2)\n * ) // { ok: true, value: 10 }\n *\n * // Async usage\n * await pipe(\n *   ok(userId),\n *   map(async id => await fetchName(id))\n * ) // Promise<Result<string, E>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: ResultMap = dual(2, (result: ResultType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (!result.ok) return result as any\n  const mapped = fn(result.value)\n  if (mapped instanceof Promise) {\n    return mapped.then(ok) as any\n  }\n  return ok(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Transform the error value of a Result.\n * If the Result is successful, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `mapErr(result, fn)`\n * - Data-last: `pipe(result, mapErr(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Result<T, F>\n * - Async fn: returns Promise<Result<T, F>>\n *\n * @param fn - Function to transform the error value\n * @returns A function that takes a Result and returns a new Result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * mapErr(err({ code: 404 }), e => `Error: ${e.code}`)\n * // { ok: false, error: 'Error: 404' }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   err({ code: 404 }),\n *   mapErr(e => `Error: ${e.code}`)\n * ) // { ok: false, error: 'Error: 404' }\n *\n * // Async usage\n * await pipe(\n *   err(errorCode),\n *   mapErr(async code => await translateError(code))\n * ) // Promise<Result<T, string>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const mapErr: ResultMapErr = dual(2, (result: ResultType<unknown, unknown>, fn: (error: unknown) => unknown) => {\n  if (result.ok) return result as any\n  const mapped = fn(result.error)\n  if (mapped instanceof Promise) {\n    return mapped.then(err) as any\n  }\n  return err(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Results.\n * If the Result is an error, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(result, fn)`\n * - Data-last: `pipe(result, flatMap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Result<U, E | E2>\n * - Async fn: returns Promise<Result<U, E | E2>>\n *\n * @param fn - Function that takes a value and returns a Result (or Promise<Result>)\n * @returns A function that takes a Result and returns a new Result\n *\n * @example\n * ```ts\n * const divide = (a: number, b: number) =>\n *   b === 0 ? err('division by zero') : ok(a / b)\n *\n * // Data-first (direct call)\n * flatMap(ok(10), n => divide(n, 2)) // { ok: true, value: 5 }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   ok(10),\n *   flatMap(n => divide(n, 2))\n * ) // { ok: true, value: 5 }\n *\n * // Async usage\n * await pipe(\n *   ok(userId),\n *   flatMap(async id => ok(await fetchUser(id)))\n * ) // Promise<Result<User, E>>\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: ResultFlatMap = dual(2, (result: ResultType<unknown, unknown>, fn: (value: unknown) => unknown) =>\n  result.ok ? fn(result.value) : result,\n)\n\n/**\n * Perform a side effect on the success value without modifying the Result.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Result is an error, the function is not called.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(result, fn)`\n * - Data-last: `pipe(result, tap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Result<T, E>\n * - Async fn: returns Promise<Result<T, E>>\n *\n * @param fn - Function to call with the success value (return value is ignored)\n * @returns A function that takes a Result and returns the same Result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * tap(ok(42), console.log) // logs 42, returns { ok: true, value: 42 }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   ok(42),\n *   tap(console.log),  // logs 42\n *   map(n => n * 2)\n * ) // { ok: true, value: 84 }\n *\n * // Async usage\n * await pipe(\n *   ok(42),\n *   tap(async v => await logToServer(v)),\n *   map(n => n * 2)\n * ) // Promise<Result<84, E>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: ResultTap = dual(2, (result: ResultType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (!result.ok) return result as any\n  const sideEffect = fn(result.value)\n  if (sideEffect instanceof Promise) {\n    return sideEffect.then(() => result) as any\n  }\n  return result as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from an error by providing an alternative Result.\n * If the Result is successful, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(result, fn)`\n * - Data-last: `pipe(result, orElse(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Result<T | U, E2>\n * - Async fn: returns Promise<Result<T | U, E2>>\n *\n * @param fn - Function that takes the error and returns an alternative Result\n * @returns A function that takes a Result and returns a new Result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * orElse(err('cache miss'), () => ok(defaultValue))\n * // { ok: true, value: defaultValue }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   err('cache miss'),\n *   orElse(() => ok(defaultValue))\n * ) // { ok: true, value: defaultValue }\n *\n * // Async recovery\n * await pipe(\n *   err('cache miss'),\n *   orElse(async () => ok(await fetchFromAPI()))\n * ) // Promise<Result<T, E2>>\n *\n * // Chain multiple fallbacks\n * pipe(\n *   err('not found'),\n *   orElse(() => tryCache()),\n *   orElse(() => tryAPI()),\n *   orElse(() => ok(fallback))\n * )\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: ResultOrElse = dual(2, (result: ResultType<unknown, unknown>, fn: (error: unknown) => unknown) =>\n  result.ok ? result : fn(result.error),\n)\n\n/**\n * Filter a successful Result based on a predicate.\n * If the predicate returns false, converts the success to an error.\n * If the Result is already an error, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(result, predicate, onFail)`\n * - Data-last: `pipe(result, filter(predicate, onFail))`\n *\n * @param predicate - Function that returns true to keep the value\n * @param onFail - Function that creates the error when predicate fails\n * @returns A function that takes a Result and returns a new Result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * filter(ok(5), n => n > 10, n => `${n} is too small`)\n * // { ok: false, error: '5 is too small' }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   ok(5),\n *   filter(n => n > 10, n => `${n} is too small`)\n * ) // { ok: false, error: '5 is too small' }\n *\n * pipe(\n *   ok(15),\n *   filter(n => n > 10, n => `${n} is too small`)\n * ) // { ok: true, value: 15 }\n *\n * // With complex validation\n * pipe(\n *   ok(user),\n *   filter(u => u.age >= 18, u => ({ code: 'UNDERAGE', user: u }))\n * )\n * ```\n */\nexport const filter: ResultFilter = dual(\n  3,\n  (\n    result: ResultType<unknown, unknown>,\n    predicate: (value: unknown) => boolean,\n    onFail: (value: unknown) => unknown,\n  ) => {\n    if (!result.ok) return result\n    return predicate(result.value) ? result : err(onFail(result.value))\n  },\n)\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Results into a single Result.\n * Supports both array and object inputs.\n *\n * - If all Results are ok, returns ok with all values\n * - If any Result is an error, returns the first error (short-circuits)\n *\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @example\n * ```ts\n * // Array form - tuple types inferred automatically for up to 6 elements\n * const [num, str] = pipe(\n *   Result.all([parseNumber(input), parseString(other)]),\n *   Result.unwrapOr([0, ''])\n * )\n *\n * // Object form - returns Result<{ user: User, config: Config }, E>\n * pipe(\n *   Result.all({ user: fetchUser(id), config: loadConfig() }),\n *   Result.tap(({ user, config }) => console.log(user.name, config.theme))\n * )\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport const all: ResultAll = (results: any): any => {\n  if (Array.isArray(results)) {\n    const values: unknown[] = []\n    for (const result of results) {\n      if (!result.ok) return result\n      values.push(result.value)\n    }\n    return ok(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, result] of Object.entries(results)) {\n    const r = result as ResultType<unknown, unknown>\n    if (!r.ok) return result\n    values[key] = r.value\n  }\n  return ok(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the success value or a default value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(result, defaultValue)`\n * - Data-last: `pipe(result, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if the Result is an error\n * @returns A function that takes a Result and returns the value or default\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * unwrapOr(ok(42), 0) // 42\n * unwrapOr(err('oops'), 0) // 0\n *\n * // Data-last (curried for pipe)\n * pipe(ok(42), unwrapOr(0)) // 42\n * pipe(err('oops'), unwrapOr(0)) // 0\n * ```\n */\nexport const unwrapOr: ResultUnwrapOr = dual(\n  2,\n  <T, E>(result: ResultType<T, E>, defaultValue: NoInfer<T>): T => (result.ok ? result.value : defaultValue),\n)\n\n/**\n * Get the success value or compute a value from the error.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(result, fn)`\n * - Data-last: `pipe(result, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute a value from the error\n * @returns A function that takes a Result and returns the value or computed value\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * unwrapOrElse(err({ code: 404 }), e => `Error ${e.code}`) // 'Error 404'\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   err({ code: 404 }),\n *   unwrapOrElse(e => `Error ${e.code}`)\n * ) // 'Error 404'\n * ```\n */\nexport const unwrapOrElse: ResultUnwrapOrElse = dual(\n  2,\n  <T, E>(result: ResultType<T, E>, fn: (error: E) => T): T => (result.ok ? result.value : fn(result.error)),\n)\n\n/**\n * Pattern match on a Result, handling both success and error cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(result, { ok: ..., err: ... })`\n * - Data-last: `pipe(result, match({ ok: ..., err: ... }))`\n *\n * @param handlers - Object with ok and err handlers\n * @returns A function that takes a Result and returns the handler result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * match(ok(42), {\n *   ok: n => `Got ${n}`,\n *   err: e => `Error: ${e}`\n * }) // 'Got 42'\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   ok(42),\n *   match({\n *     ok: n => `Got ${n}`,\n *     err: e => `Error: ${e}`\n *   })\n * ) // 'Got 42'\n * ```\n */\nexport const match: ResultMatch = dual(\n  2,\n  <T, E, U>(result: ResultType<T, E>, handlers: { ok: (value: T) => U; err: (error: E) => U }): U =>\n    result.ok ? handlers.ok(result.value) : handlers.err(result.error),\n)\n\n// ============================================================================\n// Error Boundary\n// ============================================================================\n\n/**\n * Wrap a function that might throw into a Result.\n * Supports both sync and async functions with automatic type inference.\n *\n * - Sync fn: returns Result<T, Error>\n * - Async fn: returns Promise<Result<T, Error>>\n *\n * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),\n * you should add an explicit return type annotation. This is because TypeScript's\n * conditional types cannot determine if `any` is a Promise or not, resulting in a\n * union type `Promise<Result<unknown, Error>> | Result<any, Error>` that won't work\n * with Result utilities like `isOk` or `isErr`.\n *\n * @param fn - Function that might throw (sync or async)\n * @returns A Result with the return value or the caught error\n *\n * @example\n * ```ts\n * // Sync usage\n * fromTry(() => JSON.parse('{\"valid\": true}'))\n * // { ok: true, value: { valid: true } }\n *\n * fromTry(() => JSON.parse('not json'))\n * // { ok: false, error: SyntaxError }\n *\n * // When fn returns `any`, add explicit return type:\n * fromTry((): unknown => JSON.parse(input))\n * fromTry((): MyType => JSON.parse(input))\n *\n * // Async usage\n * await fromTry(async () => await fetch('/api/user'))\n * // Promise<Result<Response, Error>>\n *\n * await fromTry(async () => {\n *   throw new Error('network error')\n * })\n * // Promise<{ ok: false, error: Error }>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for conditional return type */\nexport const fromTry = <T>(fn: () => T): FromTryReturn<T> => {\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      return result\n        .then(ok)\n        .catch((e) => err(e instanceof Error ? e : new Error(String(e)))) as unknown as FromTryReturn<T>\n    }\n    return ok(result) as unknown as FromTryReturn<T>\n  } catch (e) {\n    return err(e instanceof Error ? e : new Error(String(e))) as unknown as FromTryReturn<T>\n  }\n}\n/* oxlint-enable no-explicit-any, no-unsafe-type-assertion */\n\n// ============================================================================\n// Namespace\n// ============================================================================\n\n/**\n * Result namespace containing all utility functions for working with Result types.\n *\n * Result represents either success (ok) or failure (err). Use this for operations\n * that can fail with typed errors.\n *\n * @see {@link Option} for presence/absence semantics (no error information)\n * @see {@link Either} for two valid outcomes (not just success/failure)\n *\n * @example\n * ```ts\n * import { Result, pipe } from '@repo/std'\n * import type { Result as ResultType } from '@repo/std'\n *\n * const divide = (a: number, b: number): ResultType<number, string> =>\n *   b === 0 ? Result.err('division by zero') : Result.ok(a / b)\n *\n * const result = pipe(\n *   divide(10, 2),\n *   Result.map(n => n * 2),\n *   Result.unwrapOr(0)\n * )\n * ```\n */\nexport const Result = {\n  ok,\n  err,\n  isOk,\n  isErr,\n  map,\n  mapErr,\n  flatMap,\n  tap,\n  orElse,\n  filter,\n  all,\n  unwrapOr,\n  unwrapOrElse,\n  match,\n  fromTry,\n} as const\n"],"mappings":"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"}

package/dist/result.types-_W95221K.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result.types-_W95221K.d.mts","names":[],"sources":["../src/result/result.types.ts"],"sourcesContent":[],"mappings":"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"}