@nicolastoulemont/std 0.1.0

package/dist/result-C5tPWR60.mjs

@@ -0,0 +1,422 @@
+import { t as isPromise } from "./is-promise-BEl3eGZg.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) => ({
+	ok: true,
+	value,
+	*[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) => ({
+	ok: false,
+	error,
+	*[Symbol.iterator]() {
+		yield error;
+		throw new Error("Unreachable: Do should short-circuit on error");
+	}
+});
+/**
+* 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 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
+* // Sync usage
+* 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 = (fn) => (result) => {
+	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 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
+* // Sync usage
+* 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 = (fn) => (result) => {
+	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 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)
+*
+* // Sync usage
+* 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 = (fn) => (result) => 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 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
+* // Sync usage
+* 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 = (fn) => (result) => {
+	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 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
+* // Sync recovery
+* 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 = (fn) => (result) => 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.
+*
+* @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
+* 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 = (predicate, onFail) => (result) => {
+	if (!result.ok) return result;
+	return predicate(result.value) ? result : err(onFail(result.value));
+};
+function 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.
+*
+* @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
+* pipe(ok(42), unwrapOr(0)) // 42
+* pipe(err('oops'), unwrapOr(0)) // 0
+* ```
+*/
+const unwrapOr = (defaultValue) => (result) => result.ok ? result.value : defaultValue;
+/**
+* Get the success value or compute a value from the error.
+*
+* @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
+* pipe(
+*   err({ code: 404 }),
+*   unwrapOrElse(e => `Error ${e.code}`)
+* ) // 'Error 404'
+* ```
+*/
+const unwrapOrElse = (fn) => (result) => result.ok ? result.value : fn(result.error);
+/**
+* Pattern match on a Result, handling both success and error cases.
+*
+* @param handlers - Object with ok and err handlers
+* @returns A function that takes a Result and returns the handler result
+*
+* @example
+* ```ts
+* pipe(
+*   ok(42),
+*   match({
+*     ok: n => `Got ${n}`,
+*     err: e => `Error: ${e}`
+*   })
+* ) // 'Got 42'
+* ```
+*/
+const match = (handlers) => (result) => 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 { err as n, ok as r, Result as t };
+//# sourceMappingURL=result-C5tPWR60.mjs.map

package/dist/result-C5tPWR60.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-C5tPWR60.mjs","names":["values"],"sources":["../src/result/result.ts"],"sourcesContent":["import { isPromise } from \"../shared/is-promise\"\nimport type {\n  AllArrayReturn,\n  AllObjectReturn,\n  FromTryReturn,\n  Result as ResultType,\n  ResultFlatMap,\n  ResultMap,\n  ResultMapErr,\n  ResultTap,\n  ResultOrElse,\n  ResultFilter,\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  ok: true,\n  value,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<never, T, unknown> {\n    return value\n  },\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  ok: false,\n  error,\n  *[Symbol.iterator](): Generator<E, never, unknown> {\n    yield error\n    throw new Error(\"Unreachable: Do should short-circuit on error\")\n  },\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 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 * // Sync usage\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 = (fn) => (result) => {\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 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 * // Sync usage\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 = (fn) => (result) => {\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 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 * // Sync usage\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\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: ResultFlatMap = (fn) => (result) => (result.ok ? fn(result.value) : result) as any\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 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 * // Sync usage\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 = (fn) => (result) => {\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 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 * // Sync recovery\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 = (fn) => (result) => (result.ok ? result : fn(result.error)) as any\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 * @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 * 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 = (predicate, onFail) => (result) => {\n  if (!result.ok) return result\n  return predicate(result.value) ? result : err(onFail(result.value))\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 * @example\n * ```ts\n * // Array form (use `as const` for tuple types) - returns Result<[number, string], E>\n * const [num, str] = pipe(\n *   Result.all([parseNumber(input), parseString(other)] as const),\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 */\nexport function all<T extends readonly ResultType<unknown, unknown>[]>(results: T): AllArrayReturn<T>\nexport function all<T extends Record<string, ResultType<unknown, unknown>>>(results: T): AllObjectReturn<T>\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 function all(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 * @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 * pipe(ok(42), unwrapOr(0)) // 42\n * pipe(err('oops'), unwrapOr(0)) // 0\n * ```\n */\nexport const unwrapOr =\n  <T>(defaultValue: T) =>\n  <E>(result: ResultType<T, E>): T =>\n    result.ok ? result.value : defaultValue\n\n/**\n * Get the success value or compute a value from the error.\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 * pipe(\n *   err({ code: 404 }),\n *   unwrapOrElse(e => `Error ${e.code}`)\n * ) // 'Error 404'\n * ```\n */\nexport const unwrapOrElse =\n  <E, T>(fn: (error: E) => T) =>\n  (result: ResultType<T, E>): T =>\n    result.ok ? result.value : fn(result.error)\n\n/**\n * Pattern match on a Result, handling both success and error cases.\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 * 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 =\n  <T, E, U>(handlers: { ok: (value: T) => U; err: (error: E) => U }) =>\n  (result: ResultType<T, E>): U =>\n    result.ok ? handlers.ok(result.value) : handlers.err(result.error)\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-D7XJ96pv.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/result.types-Ce7AEOzj.d.mts

@@ -0,0 +1,156 @@
+//#region src/gen/gen.types.d.ts
+/**
+ * The yieldable protocol - any type that can be yielded in a gen computation.
+ * Implements Symbol.iterator to allow `yield*` extraction of values.
+ *
+ * @template A - The success value type
+ * @template E - The error type (yielded on failure)
+ */
+type Yieldable<A, E> = {
+  [Symbol.iterator](): Generator<E, A, unknown>;
+};
+/**
+ * Extract the success type from a Yieldable.
+ */
+type YieldableValue<T> = T extends Yieldable<infer A, unknown> ? A : never;
+/**
+ * Extract the error type from a Yieldable.
+ */
+type YieldableError<T> = T extends Yieldable<unknown, infer E> ? E : never;
+/**
+ * Sync computation - returned when using a sync generator with gen.
+ * The run() method returns Result directly (no Promise).
+ * Implements Yieldable so it can be nested in other gen computations.
+ *
+ * @template A - The success value type
+ * @template E - The error type
+ */
+type SyncComputation<A, E> = Yieldable<A, E> & {
+  /**
+   * Execute the computation synchronously.
+   * @returns Result<A, E> directly (no Promise)
+   */
+  run(): Result<A, E>;
+};
+/**
+ * Async computation - returned when using an async generator with gen.
+ * The run() method returns Promise<Result>.
+ * Does NOT implement Yieldable - cannot be yielded in sync context.
+ *
+ * @template A - The success value type
+ * @template E - The error type
+ */
+type AsyncComputation<A, E> = {
+  /**
+   * Execute the computation asynchronously.
+   * @returns Promise<Result<A, E>>
+   */
+  run(): Promise<Result<A, E>>;
+};
+/**
+ * Union type for any computation (sync or async).
+ */
+type Computation<A, E> = SyncComputation<A, E> | AsyncComputation<A, E>;
+/**
+ * Sync generator type for gen.
+ * Yields errors of type E, returns value of type A.
+ */
+type GenGenerator<A, E> = Generator<E, A, unknown>;
+/**
+ * Async generator type for gen.
+ * Yields errors of type E, returns value of type A.
+ */
+type AsyncGenGenerator<A, E> = AsyncGenerator<E, A, unknown>;
+//#endregion
+//#region src/result/result.types.d.ts
+/**
+ * A discriminated union representing either a successful result or an error.
+ * Compatible with ts-pattern for exhaustive matching.
+ * Implements Yieldable protocol for use in Do computations with yield*.
+ */
+type Result<T, E> = Yieldable<T, E> & ({
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: E;
+});
+/**
+ * Compute the return type of `fromTry` based on whether fn returns a Promise.
+ * - If fn returns Promise<T>, result is Promise<Result<T, Error>>
+ * - If fn returns T, result is Result<T, Error>
+ */
+type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Result<U, Error>> : Result<T, Error>;
+/**
+ * Extract the success type from a Result.
+ * Uses structural matching to extract the value type from the ok branch.
+ */
+type ResultValue<R> = R extends {
+  readonly ok: true;
+  readonly value: infer T;
+} ? T : never;
+/**
+ * Extract the error type from a Result.
+ * Uses structural matching to extract the error type from the err branch.
+ */
+type ResultError<R> = R extends {
+  readonly ok: false;
+  readonly error: infer E;
+} ? E : never;
+/**
+ * Compute return type for `all` with array input.
+ * Preserves tuple structure and extracts value types from each position.
+ */
+type AllArrayReturn<T extends readonly Result<unknown, unknown>[]> = Result<{ -readonly [K in keyof T]: ResultValue<T[K]> }, ResultError<T[number]>>;
+/**
+ * Compute return type for `all` with object input.
+ * Preserves object structure and extracts value types from each key.
+ */
+type AllObjectReturn<T extends Record<string, Result<unknown, unknown>>> = Result<{ -readonly [K in keyof T]: ResultValue<T[K]> }, ResultError<T[keyof T]>>;
+/**
+ * Interface for flatMap - using method syntax improves generic inference in pipe chains.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type ResultFlatMap = {
+  <A, B, E2$1>(fn: (value: A) => Promise<Result<B, E2$1>>): <E>(result: Result<A, E>) => Promise<Result<B, E | E2$1>>;
+  <A, B, E2$1>(fn: (value: A) => Result<B, E2$1>): <E>(result: Result<A, E>) => Result<B, E | E2$1>;
+};
+/**
+ * Interface for map function.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type ResultMap = {
+  <A, B>(fn: (value: A) => Promise<B>): <E>(result: Result<A, E>) => Promise<Result<B, E>>;
+  <A, B>(fn: (value: A) => B): <E>(result: Result<A, E>) => Result<B, E>;
+};
+/**
+ * Interface for mapErr function.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type ResultMapErr = {
+  <E1, E2$1>(fn: (error: E1) => Promise<E2$1>): <A>(result: Result<A, E1>) => Promise<Result<A, E2$1>>;
+  <E1, E2$1>(fn: (error: E1) => E2$1): <A>(result: Result<A, E1>) => Result<A, E2$1>;
+};
+/**
+ * Interface for tap function.
+ */
+type ResultTap = {
+  <A, R>(fn: (value: A) => R): <E>(result: Result<A, E>) => R extends Promise<unknown> ? Promise<Result<A, E>> : Result<A, E>;
+};
+/**
+ * Interface for orElse function.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type ResultOrElse = {
+  <E1, A2, E2$1>(fn: (error: E1) => Promise<Result<A2, E2$1>>): <A>(result: Result<A, E1>) => Promise<Result<A | A2, E2$1>>;
+  <E1, A2, E2$1>(fn: (error: E1) => Result<A2, E2$1>): <A>(result: Result<A, E1>) => Result<A | A2, E2$1>;
+};
+/**
+ * Interface for filter function.
+ */
+type ResultFilter = {
+  <A, E2$1>(predicate: (value: A) => boolean, onFail: (value: A) => E2$1): <E>(result: Result<A, E>) => Result<A, E | E2$1>;
+};
+//#endregion
+export { YieldableError as _, ResultFilter as a, ResultMapErr as c, AsyncComputation as d, AsyncGenGenerator as f, Yieldable as g, SyncComputation as h, Result as i, ResultOrElse as l, GenGenerator as m, AllObjectReturn as n, ResultFlatMap as o, Computation as p, FromTryReturn as r, ResultMap as s, AllArrayReturn as t, ResultTap as u, YieldableValue as v };
+//# sourceMappingURL=result.types-Ce7AEOzj.d.mts.map

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

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

package/dist/run/index.d.mts

@@ -0,0 +1,2 @@
+import { t as run } from "../index-wTrnFgYg.mjs";
+export { run };

package/dist/run/index.mjs

@@ -0,0 +1,3 @@
+import { t as run } from "../run-DpXkImo9.mjs";
+
+export { run };

package/dist/run-DpXkImo9.mjs

@@ -0,0 +1,10 @@
+import { t as gen } from "./gen-YfMC9sDT.mjs";
+
+//#region src/run/run.ts
+function run(generatorFn) {
+	return gen(generatorFn).run();
+}
+
+//#endregion
+export { run as t };
+//# sourceMappingURL=run-DpXkImo9.mjs.map

package/dist/run-DpXkImo9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-DpXkImo9.mjs","names":[],"sources":["../src/run/run.ts"],"sourcesContent":["import { gen } from \"../gen\"\nimport type { Result as ResultType } from \"../result/result.types\"\n\n/**\n * Convenience wrapper around Do() that executes the computation immediately\n * and returns the Result directly.\n *\n * Use this when you want inline execution without storing the computation.\n * For deferred execution, use Do() directly.\n *\n * @see {@link Do} for deferred/composable computations\n *\n * @example\n * ```typescript\n * // Sync computation\n * const result = run(function* () {\n *   const a = yield* divide(10, 2)\n *   const b = yield* divide(a, 2)\n *   return b\n * })  // Result<number, \"DivisionByZero\">\n *\n * // Async computation\n * const user = await run(async function* () {\n *   const data = yield* await fetchUser(1)\n *   return data.name\n * })  // Promise<Result<string, \"NotFound\">>\n *\n * // Type accumulation\n * const result = run(function* () {\n *   const a = yield* divide(10, 2)      // \"DivisionByZero\"\n *   const b = yield* findUser(a)         // \"NotFound\"\n *   return b.name\n * })  // Result<string, \"DivisionByZero\" | \"NotFound\">\n * ```\n */\n\n/**\n * Execute a sync generator computation immediately.\n *\n * @template A - The success value type\n * @template E - The error type (union of all yielded error types)\n * @param generatorFn - A function returning a sync generator\n * @returns Result<A, E> directly\n */\nexport function run<A, E>(generatorFn: () => Generator<E, A, unknown>): ResultType<A, E>\n\n/**\n * Execute an async generator computation immediately.\n *\n * @template A - The success value type\n * @template E - The error type (union of all yielded error types)\n * @param generatorFn - A function returning an async generator\n * @returns Promise<Result<A, E>>\n */\nexport function run<A, E>(generatorFn: () => AsyncGenerator<E, A, unknown>): Promise<ResultType<A, E>>\n// Implementation\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion, no-unsafe-return, no-unsafe-argument -- Required for overloaded function implementation */\nexport function run<A, E>(\n  generatorFn: (() => Generator<E, A, unknown>) | (() => AsyncGenerator<E, A, unknown>),\n): ResultType<A, E> | Promise<ResultType<A, E>> {\n  const computation = gen(generatorFn as any)\n  return computation.run() as any\n}\n/* oxlint-enable no-explicit-any, no-unsafe-type-assertion, no-unsafe-return */\n"],"mappings":";;;AAyDA,SAAgB,IACd,aAC8C;AAE9C,QADoB,IAAI,YAAmB,CACxB,KAAK"}