nalloc 0.2.2 → 0.4.0

package/build/result.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\nconst identity = <T>(v: T): T => v;\nconst wrapErr = (error: unknown): Err<never> => ERR(error) as Err<never>;\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function tryCatch<T, E>(\n  fn: () => T,\n  onError: (error: unknown) => E,\n): T extends Err<infer F> ? Err<F | E> : T extends Result<infer U, infer F> ? Result<U, F | E> : Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(error);\n  }\n}\n\n/**\n * Wraps a throwing function so it returns a Result instead.\n * The wrapper is created once and reused, avoiding per-call closure allocation.\n * @param fn - The function to wrap\n * @param onError - Optional error transformer\n * @returns A new function with the same signature that returns Result\n * @example\n * const safeParse = wrap(JSON.parse);\n * safeParse('{\"a\":1}')  // Ok({a: 1})\n * safeParse('invalid')  // Err(SyntaxError)\n */\nexport function wrap<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => Result<R, unknown>;\nexport function wrap<A extends unknown[], R, E>(fn: (...args: A) => R, onError: (error: unknown) => E): (...args: A) => Result<R, E>;\nexport function wrap<A extends unknown[], R, E = unknown>(fn: (...args: A) => R, onError?: (error: unknown) => E): (...args: A) => Result<R, E> {\n  return (...args: A) => {\n    try {\n      return fn(...args) as Ok<R>;\n    } catch (error) {\n      return ERR(onError ? onError(error) : (error as E));\n    }\n  };\n}\n\n/**\n * Converts a Result-returning function into a throwing function.\n * Inverse of wrap. Use at ecosystem boundaries where libraries expect exceptions\n * (Express error handlers, Drizzle transactions, Passport.js, etc.).\n * @param fn - A function that returns a Result\n * @returns A new function that returns the Ok value or throws the Err error\n * @example\n * const findUser = (id: string): Result<User, NotFoundError> => { ... };\n * const throwingFind = toThrowable(findUser);\n * throwingFind('123') // returns User or throws NotFoundError\n */\nexport function toThrowable<A extends unknown[], R, E>(fn: (...args: A) => Result<R, E>): (...args: A) => R {\n  return (...args: A) => {\n    const result = fn(...args);\n    if (isErr(result)) throw result.error;\n    return result;\n  };\n}\n\n/**\n * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.\n * @param promise - The promise to convert\n * @param onError - Optional error transformer\n * @returns Promise resolving to Ok(value) or Err(error)\n * @example\n * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)\n * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)\n */\nexport async function fromPromise<T>(promise: Promise<Exclude<T, Err<any>>>): Promise<Result<T, unknown>>;\nexport async function fromPromise<T, E>(promise: Promise<Exclude<T, Err<any>>>, onError: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/** A validation issue from a Standard Schema validator. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */\nexport interface StandardSchema<O = unknown> {\n  readonly '~standard': {\n    readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;\n  };\n}\n\ntype StandardSchemaResult<O> = { readonly value: O; readonly issues?: undefined } | { readonly issues: ReadonlyArray<SchemaIssue> };\n\nfunction schemaResultToResult<O>(sr: StandardSchemaResult<O>): Result<O, readonly SchemaIssue[]> {\n  return sr.issues ? ERR(sr.issues) : (sr.value as Ok<O>);\n}\n\n/**\n * Validates a value against a Standard Schema and returns a Result.\n * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).\n * Returns synchronously if the schema validates synchronously.\n * @param schema - A Standard Schema v1 compliant schema\n * @param value - The value to validate\n * @returns Ok(parsed) if valid, Err(issues) if invalid\n * @example\n * import { z } from 'zod';\n * const result = fromSchema(z.string().email(), input);\n * // Result<string, readonly SchemaIssue[]>\n */\nexport function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  const sr = schema['~standard'].validate(value);\n  if (isThenable(sr)) return sr.then(schemaResultToResult);\n  return schemaResultToResult(sr);\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? `Expected Err result. Received value: ${String(result)}`);\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an array of Results.\n * @param results - Array of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Result<T, E>[]): T[] {\n  const oks: T[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an array of Results.\n * @param results - Array of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Result<T, E>[]): E[] {\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR(result.error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < settled.length; i++) {\n    const entry = settled[i];\n\n    if (entry.status === 'rejected') {\n      errs.push(entry.reason as WidenNever<E>);\n      continue;\n    }\n\n    const result = entry.value;\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push(result.error as WidenNever<E>);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len).fill(0 as never);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const remaining = values.length - startIndex;\n  const promises = new Array<Promise<Result<T, E>>>(remaining).fill(0 as never);\n\n  for (let i = 0; i < remaining; i++) {\n    const value = values[startIndex + i];\n    promises[i] = isThenable(value) ? Promise.resolve(value).then(identity, wrapErr) : Promise.resolve(value);\n  }\n\n  const resolved = await Promise.all(promises);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\nfunction* unwrapYield<T, E>(result: Result<T, E>): Generator<Err<E>, T> {\n  if (isErr(result)) {\n    yield result;\n    return undefined as never;\n  }\n  return result;\n}\n\ntype Unwrapper = <T, E>(result: Result<T, E>) => Generator<Err<E>, T>;\n\n/**\n * Generator-based do-notation for Result. Provides a `$` function that unwraps\n * Results inside a generator, short-circuiting on the first Err.\n * Preserves error types (unlike safeTry which erases to unknown).\n * @param fn - Generator function receiving `$` unwrapper\n * @returns Ok(return value) or the first Err encountered\n * @example\n * const result = gen(function*($) {\n *   const a = yield* $(parseNumber('10'));\n *   const b = yield* $(parseNumber('5'));\n *   return a + b;\n * }); // Result<number, ParseError>\n */\nexport function gen<E, T>(fn: ($: Unwrapper) => Generator<Err<E>, T>): Result<T, E> {\n  const iter = fn(unwrapYield);\n  const step = iter.next();\n  if (!step.done) return step.value;\n  return step.value as Ok<T>;\n}\n\n/**\n * Async generator-based do-notation for Result. Like gen, but for async operations.\n * @param fn - Async generator function receiving `$` unwrapper\n * @returns Promise of Ok(return value) or the first Err encountered\n * @example\n * const result = await genAsync(async function*($) {\n *   const user = yield* $(await fetchUser(id));\n *   const posts = yield* $(await fetchPosts(user.id));\n *   return { user, posts };\n * }); // Promise<Result<{user, posts}, FetchError>>\n */\nexport async function genAsync<E, T>(fn: ($: Unwrapper) => AsyncGenerator<Err<E>, T>): Promise<Result<T, E>> {\n  const iter = fn(unwrapYield);\n  const step = await iter.next();\n  if (!step.done) return step.value;\n  return step.value as Ok<T>;\n}\n"],"names":["all","and","andThen","any","assertErr","assertOk","bimap","collect","collectAll","expect","expectErr","filterErr","filterOk","flatMap","flatten","fromPromise","fromSchema","gen","genAsync","isErr","isErrAnd","isOk","isOkAnd","isSomeErr","map","mapErr","mapOr","mapOrElse","match","of","or","orElse","partition","partitionAsync","partitionMaybePromise","partitionMaybePromiseAsync","safeTry","safeTryAsync","settleMaybePromise","tap","tapErr","toErrorOption","toOption","toThrowable","transpose","tryCatch","tryCatchMaybePromise","unwrap","unwrapErr","unwrapOr","unwrapOrElse","unwrapOrReturn","wrap","zip","zipWith","identity","v","wrapErr","error","ERR","fn","onError","args","result","promise","schemaResultToResult","sr","issues","value","schema","validate","isThenable","then","Promise","resolve","onErr","message","Error","String","isSome","okFn","errFn","defaultValue","defaultFn","other","optionOf","NONE","left","right","onOk","results","oks","errs","i","length","push","values","errors","opt","isNone","predicate","promises","settled","allSettled","entry","status","reason","len","Array","fill","pendingIndices","pendingPromises","s","startIndex","remaining","resolved","e","unwrapYield","undefined","iter","step","next","done"],"mappings":"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"}
+{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\nimport type { NonEmptyArray } from './nonempty.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\nconst identity = <T>(v: T): T => v;\nconst wrapErr = (error: unknown): Err<never> => ERR(error) as Err<never>;\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function tryCatch<T, E>(\n  fn: () => T,\n  onError: (error: unknown) => E,\n): T extends Err<infer F> ? Err<F | E> : T extends Result<infer U, infer F> ? Result<U, F | E> : Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(error);\n  }\n}\n\n/**\n * Wraps a throwing function so it returns a Result instead.\n * The wrapper is created once and reused, avoiding per-call closure allocation.\n * @param fn - The function to wrap\n * @param onError - Optional error transformer\n * @returns A new function with the same signature that returns Result\n * @example\n * const safeParse = wrap(JSON.parse);\n * safeParse('{\"a\":1}')  // Ok({a: 1})\n * safeParse('invalid')  // Err(SyntaxError)\n */\nexport function wrap<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => Result<R, unknown>;\nexport function wrap<A extends unknown[], R, E>(fn: (...args: A) => R, onError: (error: unknown) => E): (...args: A) => Result<R, E>;\nexport function wrap<A extends unknown[], R, E = unknown>(fn: (...args: A) => R, onError?: (error: unknown) => E): (...args: A) => Result<R, E> {\n  return (...args: A) => {\n    try {\n      return fn(...args) as Ok<R>;\n    } catch (error) {\n      return ERR(onError ? onError(error) : (error as E));\n    }\n  };\n}\n\n/**\n * Converts a Result-returning function into a throwing function.\n * Inverse of wrap. Use at ecosystem boundaries where libraries expect exceptions\n * (Express error handlers, Drizzle transactions, Passport.js, etc.).\n * @param fn - A function that returns a Result\n * @returns A new function that returns the Ok value or throws the Err error\n * @example\n * const findUser = (id: string): Result<User, NotFoundError> => { ... };\n * const throwingFind = toThrowable(findUser);\n * throwingFind('123') // returns User or throws NotFoundError\n */\nexport function toThrowable<A extends unknown[], R, E>(fn: (...args: A) => Result<R, E>): (...args: A) => R {\n  return (...args: A) => {\n    const result = fn(...args);\n    if (isErr(result)) throw result.error;\n    return result;\n  };\n}\n\n/**\n * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.\n * @param promise - The promise to convert\n * @param onError - Optional error transformer\n * @returns Promise resolving to Ok(value) or Err(error)\n * @example\n * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)\n * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)\n */\nexport async function fromPromise<T>(promise: Promise<Exclude<T, Err<any>>>): Promise<Result<T, unknown>>;\nexport async function fromPromise<T, E>(promise: Promise<Exclude<T, Err<any>>>, onError: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/** A validation issue from a Standard Schema validator. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */\nexport interface StandardSchema<O = unknown> {\n  readonly '~standard': {\n    readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;\n  };\n}\n\ntype StandardSchemaResult<O> = { readonly value: O; readonly issues?: undefined } | { readonly issues: ReadonlyArray<SchemaIssue> };\n\nfunction schemaResultToResult<O>(sr: StandardSchemaResult<O>): Result<O, readonly SchemaIssue[]> {\n  return sr.issues ? ERR(sr.issues) : (sr.value as Ok<O>);\n}\n\n/**\n * Validates a value against a Standard Schema and returns a Result.\n * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).\n * Returns synchronously if the schema validates synchronously.\n * @param schema - A Standard Schema v1 compliant schema\n * @param value - The value to validate\n * @returns Ok(parsed) if valid, Err(issues) if invalid\n * @example\n * import { z } from 'zod';\n * const result = fromSchema(z.string().email(), input);\n * // Result<string, readonly SchemaIssue[]>\n */\nexport function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  const sr = schema['~standard'].validate(value);\n  if (isThenable(sr)) return sr.then(schemaResultToResult);\n  return schemaResultToResult(sr);\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? `Expected Err result. Received value: ${String(result)}`);\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an array of Results.\n * @param results - Array of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Result<T, E>[]): T[] {\n  const oks: T[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an array of Results.\n * @param results - Array of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Result<T, E>[]): E[] {\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], NonEmptyArray<E>> {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n  return errs.length > 0 ? ERR(errs as NonEmptyArray<E>) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: NonEmptyArray<Result<T, E>>): Result<Widen<T>, NonEmptyArray<WidenNever<E>>> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors as NonEmptyArray<WidenNever<E>>);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return result as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < settled.length; i++) {\n    const entry = settled[i];\n\n    if (entry.status === 'rejected') {\n      errs.push(entry.reason as WidenNever<E>);\n      continue;\n    }\n\n    const result = entry.value;\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push(result.error as WidenNever<E>);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len).fill(0 as never);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const remaining = values.length - startIndex;\n  const promises = new Array<Promise<Result<T, E>>>(remaining).fill(0 as never);\n\n  for (let i = 0; i < remaining; i++) {\n    const value = values[startIndex + i];\n    promises[i] = isThenable(value) ? Promise.resolve(value).then(identity, wrapErr) : Promise.resolve(value);\n  }\n\n  const resolved = await Promise.all(promises);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\nfunction* unwrapYield<T, E>(result: Result<T, E>): Generator<Err<E>, T> {\n  if (isErr(result)) yield result;\n  return result as T;\n}\n\ntype Unwrapper = <T, E>(result: Result<T, E>) => Generator<Err<E>, T>;\n\n/**\n * Generator-based do-notation for Result. Provides a `$` function that unwraps\n * Results inside a generator, short-circuiting on the first Err.\n * Preserves error types (unlike safeTry which erases to unknown).\n * @param fn - Generator function receiving `$` unwrapper\n * @returns Ok(return value) or the first Err encountered\n * @example\n * const result = gen(function*($) {\n *   const a = yield* $(parseNumber('10'));\n *   const b = yield* $(parseNumber('5'));\n *   return a + b;\n * }); // Result<number, ParseError>\n */\nexport function gen<E, T>(fn: ($: Unwrapper) => Generator<Err<E>, T>): Result<T, E> {\n  const iter = fn(unwrapYield);\n  const step = iter.next();\n  if (!step.done) {\n    // short-circuit abandons the generator mid-body; resume it so try/finally cleanup runs\n    iter.return(undefined as never);\n    return step.value;\n  }\n  return step.value as Ok<T>;\n}\n\n/**\n * Async generator-based do-notation for Result. Like gen, but for async operations.\n * @param fn - Async generator function receiving `$` unwrapper\n * @returns Promise of Ok(return value) or the first Err encountered\n * @example\n * const result = await genAsync(async function*($) {\n *   const user = yield* $(await fetchUser(id));\n *   const posts = yield* $(await fetchPosts(user.id));\n *   return { user, posts };\n * }); // Promise<Result<{user, posts}, FetchError>>\n */\nexport async function genAsync<E, T>(fn: ($: Unwrapper) => AsyncGenerator<Err<E>, T>): Promise<Result<T, E>> {\n  const iter = fn(unwrapYield);\n  const step = await iter.next();\n  if (!step.done) {\n    // short-circuit abandons the generator mid-body; resume it so try/finally cleanup runs\n    await iter.return(undefined as never);\n    return step.value;\n  }\n  return step.value as Ok<T>;\n}\n"],"names":["all","and","andThen","any","assertErr","assertOk","bimap","collect","collectAll","expect","expectErr","filterErr","filterOk","flatMap","flatten","fromPromise","fromSchema","gen","genAsync","isErr","isErrAnd","isOk","isOkAnd","isSomeErr","map","mapErr","mapOr","mapOrElse","match","of","or","orElse","partition","partitionAsync","partitionMaybePromise","partitionMaybePromiseAsync","safeTry","safeTryAsync","settleMaybePromise","tap","tapErr","toErrorOption","toOption","toThrowable","transpose","tryCatch","tryCatchMaybePromise","unwrap","unwrapErr","unwrapOr","unwrapOrElse","unwrapOrReturn","wrap","zip","zipWith","identity","v","wrapErr","error","ERR","fn","onError","args","result","promise","schemaResultToResult","sr","issues","value","schema","validate","isThenable","then","Promise","resolve","onErr","message","Error","String","isSome","okFn","errFn","defaultValue","defaultFn","other","optionOf","NONE","left","right","onOk","results","oks","errs","i","length","push","values","errors","opt","isNone","predicate","promises","settled","allSettled","entry","status","reason","len","Array","fill","pendingIndices","pendingPromises","s","startIndex","remaining","resolved","e","unwrapYield","iter","step","next","done","return","undefined"],"mappings":"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"}

package/build/result.d.ts

@@ -1,5 +1,6 @@
 import { isOk, isErr } from './types.js';
 import type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';
+import type { NonEmptyArray } from './nonempty.js';
 export type { Ok, Err, Result };
 export { isOk, isErr };
 /**
@@ -433,7 +434,7 @@ export declare function collect<T, E>(results: Result<T, E>[]): Result<T[], E>;
  * collectAll([ok(1), ok(2)])           // Ok([1, 2])
  * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])
  */
-export declare function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]>;
+export declare function collectAll<T, E>(results: Result<T, E>[]): Result<T[], NonEmptyArray<E>>;
 /**
  * Alias for collect with widened types. Collects Results into a Result of array.
  * @param results - Array of Results
@@ -448,7 +449,7 @@ export declare function all<T, E>(results: Result<T, E>[]): Result<readonly Wide
  * any([err('a'), ok(1), err('b')]) // Ok(1)
  * any([err('a'), err('b')])        // Err(['a', 'b'])
  */
-export declare function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]>;
+export declare function any<T, E>(results: NonEmptyArray<Result<T, E>>): Result<Widen<T>, NonEmptyArray<WidenNever<E>>>;
 /**
  * Transposes a Result of Option to an Option of Result.
  * @param result - Result containing an Option

package/build/result.js

@@ -238,7 +238,7 @@ export function any(results) {
 }
 export function transpose(result) {
     if (isErr(result)) {
-        return ERR(result.error);
+        return result;
     }
     const opt = result;
     return isNone(opt) ? NONE : opt;
@@ -350,22 +350,25 @@ export async function safeTryAsync(fn) {
     }
 }
 function* unwrapYield(result) {
-    if (isErr(result)) {
-        yield result;
-        return undefined;
-    }
+    if (isErr(result)) yield result;
     return result;
 }
 export function gen(fn) {
     const iter = fn(unwrapYield);
     const step = iter.next();
-    if (!step.done) return step.value;
+    if (!step.done) {
+        iter.return(undefined);
+        return step.value;
+    }
     return step.value;
 }
 export async function genAsync(fn) {
     const iter = fn(unwrapYield);
     const step = await iter.next();
-    if (!step.done) return step.value;
+    if (!step.done) {
+        await iter.return(undefined);
+        return step.value;
+    }
     return step.value;
 }
 

package/build/result.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\nconst identity = <T>(v: T): T => v;\nconst wrapErr = (error: unknown): Err<never> => ERR(error) as Err<never>;\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function tryCatch<T, E>(\n  fn: () => T,\n  onError: (error: unknown) => E,\n): T extends Err<infer F> ? Err<F | E> : T extends Result<infer U, infer F> ? Result<U, F | E> : Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(error);\n  }\n}\n\n/**\n * Wraps a throwing function so it returns a Result instead.\n * The wrapper is created once and reused, avoiding per-call closure allocation.\n * @param fn - The function to wrap\n * @param onError - Optional error transformer\n * @returns A new function with the same signature that returns Result\n * @example\n * const safeParse = wrap(JSON.parse);\n * safeParse('{\"a\":1}')  // Ok({a: 1})\n * safeParse('invalid')  // Err(SyntaxError)\n */\nexport function wrap<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => Result<R, unknown>;\nexport function wrap<A extends unknown[], R, E>(fn: (...args: A) => R, onError: (error: unknown) => E): (...args: A) => Result<R, E>;\nexport function wrap<A extends unknown[], R, E = unknown>(fn: (...args: A) => R, onError?: (error: unknown) => E): (...args: A) => Result<R, E> {\n  return (...args: A) => {\n    try {\n      return fn(...args) as Ok<R>;\n    } catch (error) {\n      return ERR(onError ? onError(error) : (error as E));\n    }\n  };\n}\n\n/**\n * Converts a Result-returning function into a throwing function.\n * Inverse of wrap. Use at ecosystem boundaries where libraries expect exceptions\n * (Express error handlers, Drizzle transactions, Passport.js, etc.).\n * @param fn - A function that returns a Result\n * @returns A new function that returns the Ok value or throws the Err error\n * @example\n * const findUser = (id: string): Result<User, NotFoundError> => { ... };\n * const throwingFind = toThrowable(findUser);\n * throwingFind('123') // returns User or throws NotFoundError\n */\nexport function toThrowable<A extends unknown[], R, E>(fn: (...args: A) => Result<R, E>): (...args: A) => R {\n  return (...args: A) => {\n    const result = fn(...args);\n    if (isErr(result)) throw result.error;\n    return result;\n  };\n}\n\n/**\n * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.\n * @param promise - The promise to convert\n * @param onError - Optional error transformer\n * @returns Promise resolving to Ok(value) or Err(error)\n * @example\n * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)\n * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)\n */\nexport async function fromPromise<T>(promise: Promise<Exclude<T, Err<any>>>): Promise<Result<T, unknown>>;\nexport async function fromPromise<T, E>(promise: Promise<Exclude<T, Err<any>>>, onError: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/** A validation issue from a Standard Schema validator. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */\nexport interface StandardSchema<O = unknown> {\n  readonly '~standard': {\n    readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;\n  };\n}\n\ntype StandardSchemaResult<O> = { readonly value: O; readonly issues?: undefined } | { readonly issues: ReadonlyArray<SchemaIssue> };\n\nfunction schemaResultToResult<O>(sr: StandardSchemaResult<O>): Result<O, readonly SchemaIssue[]> {\n  return sr.issues ? ERR(sr.issues) : (sr.value as Ok<O>);\n}\n\n/**\n * Validates a value against a Standard Schema and returns a Result.\n * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).\n * Returns synchronously if the schema validates synchronously.\n * @param schema - A Standard Schema v1 compliant schema\n * @param value - The value to validate\n * @returns Ok(parsed) if valid, Err(issues) if invalid\n * @example\n * import { z } from 'zod';\n * const result = fromSchema(z.string().email(), input);\n * // Result<string, readonly SchemaIssue[]>\n */\nexport function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  const sr = schema['~standard'].validate(value);\n  if (isThenable(sr)) return sr.then(schemaResultToResult);\n  return schemaResultToResult(sr);\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? `Expected Err result. Received value: ${String(result)}`);\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an array of Results.\n * @param results - Array of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Result<T, E>[]): T[] {\n  const oks: T[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an array of Results.\n * @param results - Array of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Result<T, E>[]): E[] {\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR(result.error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < settled.length; i++) {\n    const entry = settled[i];\n\n    if (entry.status === 'rejected') {\n      errs.push(entry.reason as WidenNever<E>);\n      continue;\n    }\n\n    const result = entry.value;\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push(result.error as WidenNever<E>);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len).fill(0 as never);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const remaining = values.length - startIndex;\n  const promises = new Array<Promise<Result<T, E>>>(remaining).fill(0 as never);\n\n  for (let i = 0; i < remaining; i++) {\n    const value = values[startIndex + i];\n    promises[i] = isThenable(value) ? Promise.resolve(value).then(identity, wrapErr) : Promise.resolve(value);\n  }\n\n  const resolved = await Promise.all(promises);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\nfunction* unwrapYield<T, E>(result: Result<T, E>): Generator<Err<E>, T> {\n  if (isErr(result)) {\n    yield result;\n    return undefined as never;\n  }\n  return result;\n}\n\ntype Unwrapper = <T, E>(result: Result<T, E>) => Generator<Err<E>, T>;\n\n/**\n * Generator-based do-notation for Result. Provides a `$` function that unwraps\n * Results inside a generator, short-circuiting on the first Err.\n * Preserves error types (unlike safeTry which erases to unknown).\n * @param fn - Generator function receiving `$` unwrapper\n * @returns Ok(return value) or the first Err encountered\n * @example\n * const result = gen(function*($) {\n *   const a = yield* $(parseNumber('10'));\n *   const b = yield* $(parseNumber('5'));\n *   return a + b;\n * }); // Result<number, ParseError>\n */\nexport function gen<E, T>(fn: ($: Unwrapper) => Generator<Err<E>, T>): Result<T, E> {\n  const iter = fn(unwrapYield);\n  const step = iter.next();\n  if (!step.done) return step.value;\n  return step.value as Ok<T>;\n}\n\n/**\n * Async generator-based do-notation for Result. Like gen, but for async operations.\n * @param fn - Async generator function receiving `$` unwrapper\n * @returns Promise of Ok(return value) or the first Err encountered\n * @example\n * const result = await genAsync(async function*($) {\n *   const user = yield* $(await fetchUser(id));\n *   const posts = yield* $(await fetchPosts(user.id));\n *   return { user, posts };\n * }); // Promise<Result<{user, posts}, FetchError>>\n */\nexport async function genAsync<E, T>(fn: ($: Unwrapper) => AsyncGenerator<Err<E>, T>): Promise<Result<T, E>> {\n  const iter = fn(unwrapYield);\n  const step = await iter.next();\n  if (!step.done) return step.value;\n  return step.value as Ok<T>;\n}\n"],"names":["err","ERR","isOk","isErr","isSome","isNone","NONE","optionOf","isThenable","identity","v","wrapErr","error","tryCatch","fn","onError","of","wrap","args","toThrowable","result","fromPromise","promise","schemaResultToResult","sr","issues","value","fromSchema","schema","validate","then","tryCatchMaybePromise","Promise","resolve","unwrapOrReturn","onErr","assertOk","message","Error","String","assertErr","isSomeErr","map","mapErr","flatMap","andThen","tap","tapErr","bimap","okFn","errFn","unwrap","unwrapErr","unwrapOr","defaultValue","unwrapOrElse","mapOr","mapOrElse","defaultFn","expect","expectErr","and","other","or","orElse","toOption","toErrorOption","zip","left","right","zipWith","flatten","match","onOk","partition","results","oks","errs","i","length","push","filterOk","filterErr","collect","values","collectAll","all","any","errors","transpose","opt","isOkAnd","predicate","isErrAnd","partitionAsync","promises","settled","allSettled","entry","status","reason","settleMaybePromise","len","Array","fill","pendingIndices","pendingPromises","s","partitionMaybePromiseAsync","startIndex","remaining","resolved","partitionMaybePromise","safeTry","e","safeTryAsync","unwrapYield","undefined","gen","iter","step","next","done","genAsync"],"mappings":"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"}
+{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\nimport type { NonEmptyArray } from './nonempty.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\nconst identity = <T>(v: T): T => v;\nconst wrapErr = (error: unknown): Err<never> => ERR(error) as Err<never>;\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function tryCatch<T, E>(\n  fn: () => T,\n  onError: (error: unknown) => E,\n): T extends Err<infer F> ? Err<F | E> : T extends Result<infer U, infer F> ? Result<U, F | E> : Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): T extends Err<any> ? Err<unknown> : T extends Result<infer U, any> ? Result<U, unknown> : Result<T, unknown>;\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(error);\n  }\n}\n\n/**\n * Wraps a throwing function so it returns a Result instead.\n * The wrapper is created once and reused, avoiding per-call closure allocation.\n * @param fn - The function to wrap\n * @param onError - Optional error transformer\n * @returns A new function with the same signature that returns Result\n * @example\n * const safeParse = wrap(JSON.parse);\n * safeParse('{\"a\":1}')  // Ok({a: 1})\n * safeParse('invalid')  // Err(SyntaxError)\n */\nexport function wrap<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => Result<R, unknown>;\nexport function wrap<A extends unknown[], R, E>(fn: (...args: A) => R, onError: (error: unknown) => E): (...args: A) => Result<R, E>;\nexport function wrap<A extends unknown[], R, E = unknown>(fn: (...args: A) => R, onError?: (error: unknown) => E): (...args: A) => Result<R, E> {\n  return (...args: A) => {\n    try {\n      return fn(...args) as Ok<R>;\n    } catch (error) {\n      return ERR(onError ? onError(error) : (error as E));\n    }\n  };\n}\n\n/**\n * Converts a Result-returning function into a throwing function.\n * Inverse of wrap. Use at ecosystem boundaries where libraries expect exceptions\n * (Express error handlers, Drizzle transactions, Passport.js, etc.).\n * @param fn - A function that returns a Result\n * @returns A new function that returns the Ok value or throws the Err error\n * @example\n * const findUser = (id: string): Result<User, NotFoundError> => { ... };\n * const throwingFind = toThrowable(findUser);\n * throwingFind('123') // returns User or throws NotFoundError\n */\nexport function toThrowable<A extends unknown[], R, E>(fn: (...args: A) => Result<R, E>): (...args: A) => R {\n  return (...args: A) => {\n    const result = fn(...args);\n    if (isErr(result)) throw result.error;\n    return result;\n  };\n}\n\n/**\n * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.\n * @param promise - The promise to convert\n * @param onError - Optional error transformer\n * @returns Promise resolving to Ok(value) or Err(error)\n * @example\n * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)\n * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)\n */\nexport async function fromPromise<T>(promise: Promise<Exclude<T, Err<any>>>): Promise<Result<T, unknown>>;\nexport async function fromPromise<T, E>(promise: Promise<Exclude<T, Err<any>>>, onError: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/** A validation issue from a Standard Schema validator. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */\nexport interface StandardSchema<O = unknown> {\n  readonly '~standard': {\n    readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;\n  };\n}\n\ntype StandardSchemaResult<O> = { readonly value: O; readonly issues?: undefined } | { readonly issues: ReadonlyArray<SchemaIssue> };\n\nfunction schemaResultToResult<O>(sr: StandardSchemaResult<O>): Result<O, readonly SchemaIssue[]> {\n  return sr.issues ? ERR(sr.issues) : (sr.value as Ok<O>);\n}\n\n/**\n * Validates a value against a Standard Schema and returns a Result.\n * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).\n * Returns synchronously if the schema validates synchronously.\n * @param schema - A Standard Schema v1 compliant schema\n * @param value - The value to validate\n * @returns Ok(parsed) if valid, Err(issues) if invalid\n * @example\n * import { z } from 'zod';\n * const result = fromSchema(z.string().email(), input);\n * // Result<string, readonly SchemaIssue[]>\n */\nexport function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  const sr = schema['~standard'].validate(value);\n  if (isThenable(sr)) return sr.then(schemaResultToResult);\n  return schemaResultToResult(sr);\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? `Expected Err result. Received value: ${String(result)}`);\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an array of Results.\n * @param results - Array of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Result<T, E>[]): T[] {\n  const oks: T[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an array of Results.\n * @param results - Array of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Result<T, E>[]): E[] {\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], NonEmptyArray<E>> {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n  return errs.length > 0 ? ERR(errs as NonEmptyArray<E>) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: NonEmptyArray<Result<T, E>>): Result<Widen<T>, NonEmptyArray<WidenNever<E>>> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors as NonEmptyArray<WidenNever<E>>);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return result as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < settled.length; i++) {\n    const entry = settled[i];\n\n    if (entry.status === 'rejected') {\n      errs.push(entry.reason as WidenNever<E>);\n      continue;\n    }\n\n    const result = entry.value;\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push(result.error as WidenNever<E>);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len).fill(0 as never);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const remaining = values.length - startIndex;\n  const promises = new Array<Promise<Result<T, E>>>(remaining).fill(0 as never);\n\n  for (let i = 0; i < remaining; i++) {\n    const value = values[startIndex + i];\n    promises[i] = isThenable(value) ? Promise.resolve(value).then(identity, wrapErr) : Promise.resolve(value);\n  }\n\n  const resolved = await Promise.all(promises);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\nfunction* unwrapYield<T, E>(result: Result<T, E>): Generator<Err<E>, T> {\n  if (isErr(result)) yield result;\n  return result as T;\n}\n\ntype Unwrapper = <T, E>(result: Result<T, E>) => Generator<Err<E>, T>;\n\n/**\n * Generator-based do-notation for Result. Provides a `$` function that unwraps\n * Results inside a generator, short-circuiting on the first Err.\n * Preserves error types (unlike safeTry which erases to unknown).\n * @param fn - Generator function receiving `$` unwrapper\n * @returns Ok(return value) or the first Err encountered\n * @example\n * const result = gen(function*($) {\n *   const a = yield* $(parseNumber('10'));\n *   const b = yield* $(parseNumber('5'));\n *   return a + b;\n * }); // Result<number, ParseError>\n */\nexport function gen<E, T>(fn: ($: Unwrapper) => Generator<Err<E>, T>): Result<T, E> {\n  const iter = fn(unwrapYield);\n  const step = iter.next();\n  if (!step.done) {\n    // short-circuit abandons the generator mid-body; resume it so try/finally cleanup runs\n    iter.return(undefined as never);\n    return step.value;\n  }\n  return step.value as Ok<T>;\n}\n\n/**\n * Async generator-based do-notation for Result. Like gen, but for async operations.\n * @param fn - Async generator function receiving `$` unwrapper\n * @returns Promise of Ok(return value) or the first Err encountered\n * @example\n * const result = await genAsync(async function*($) {\n *   const user = yield* $(await fetchUser(id));\n *   const posts = yield* $(await fetchPosts(user.id));\n *   return { user, posts };\n * }); // Promise<Result<{user, posts}, FetchError>>\n */\nexport async function genAsync<E, T>(fn: ($: Unwrapper) => AsyncGenerator<Err<E>, T>): Promise<Result<T, E>> {\n  const iter = fn(unwrapYield);\n  const step = await iter.next();\n  if (!step.done) {\n    // short-circuit abandons the generator mid-body; resume it so try/finally cleanup runs\n    await iter.return(undefined as never);\n    return step.value;\n  }\n  return step.value as Ok<T>;\n}\n"],"names":["err","ERR","isOk","isErr","isSome","isNone","NONE","optionOf","isThenable","identity","v","wrapErr","error","tryCatch","fn","onError","of","wrap","args","toThrowable","result","fromPromise","promise","schemaResultToResult","sr","issues","value","fromSchema","schema","validate","then","tryCatchMaybePromise","Promise","resolve","unwrapOrReturn","onErr","assertOk","message","Error","String","assertErr","isSomeErr","map","mapErr","flatMap","andThen","tap","tapErr","bimap","okFn","errFn","unwrap","unwrapErr","unwrapOr","defaultValue","unwrapOrElse","mapOr","mapOrElse","defaultFn","expect","expectErr","and","other","or","orElse","toOption","toErrorOption","zip","left","right","zipWith","flatten","match","onOk","partition","results","oks","errs","i","length","push","filterOk","filterErr","collect","values","collectAll","all","any","errors","transpose","opt","isOkAnd","predicate","isErrAnd","partitionAsync","promises","settled","allSettled","entry","status","reason","settleMaybePromise","len","Array","fill","pendingIndices","pendingPromises","s","partitionMaybePromiseAsync","startIndex","remaining","resolved","partitionMaybePromise","safeTry","e","safeTryAsync","unwrapYield","gen","iter","step","next","done","return","undefined","genAsync"],"mappings":"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"}

package/build/safe.cjs

@@ -12,6 +12,9 @@ _export(exports, {
     get Iter () {
         return _itercjs;
     },
+    get NonEmpty () {
+        return _nonemptycjs;
+    },
     get Option () {
         return _optioncjs;
     },
@@ -71,6 +74,7 @@ const _typescjs = require("./types.cjs");
 const _resultcjs = /*#__PURE__*/ _interop_require_wildcard(require("./result.cjs"));
 const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
 const _itercjs = /*#__PURE__*/ _interop_require_wildcard(require("./iter.cjs"));
+const _nonemptycjs = /*#__PURE__*/ _interop_require_wildcard(require("./nonempty.cjs"));
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();

package/build/safe.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["Iter","Option","Result","err","gen","genAsync","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","pipe","safeTry","safeTryAsync","some","unwrap","a","fns","result","i","length"],"mappings":";;;;;;;;;;;QAoBYA;;;QAFAC;;;QACAC;;;QAnBaC;eAAAA,aAAG;;QAiBYC;eAAAA,cAAG;;QAAEC;eAAAA,mBAAQ;;QAjBjBC;eAAAA,eAAK;;QAAUC;eAAAA,gBAAM;;QAA3BC;eAAAA,cAAI;;QAASC;eAAAA,gBAAM;;QAAsBC;eAAAA,gBAAM;;QAAlBC;eAAAA,oBAAU;;QAAtDC;eAAAA,cAAI;;QAAEC;eAAAA,YAAE;;QA8DPC;eAAAA;;QA7CPC;eAAAA,kBAAO;;QAAEC;eAAAA,uBAAY;;QAjBrBC;eAAAA,cAAI;;QAiBmBC;eAAAA,iBAAM;;;0BAjB+C;mEAiBxB;mEACrC;iEAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0Cf,SAASJ,KAAKK,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\nexport * as NonEmpty from './nonempty.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["Iter","NonEmpty","Option","Result","err","gen","genAsync","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","pipe","safeTry","safeTryAsync","some","unwrap","a","fns","result","i","length"],"mappings":";;;;;;;;;;;QAqBYA;;;QACAC;;;QAHAC;;;QACAC;;;QApBaC;eAAAA,aAAG;;QAiBYC;eAAAA,cAAG;;QAAEC;eAAAA,mBAAQ;;QAjBjBC;eAAAA,eAAK;;QAAUC;eAAAA,gBAAM;;QAA3BC;eAAAA,cAAI;;QAASC;eAAAA,gBAAM;;QAAsBC;eAAAA,gBAAM;;QAAlBC;eAAAA,oBAAU;;QAAtDC;eAAAA,cAAI;;QAAEC;eAAAA,YAAE;;QAgEPC;eAAAA;;QA/CPC;eAAAA,kBAAO;;QAAEC;eAAAA,uBAAY;;QAjBrBC;eAAAA,cAAI;;QAiBmBC;eAAAA,iBAAM;;;0BAjB+C;mEAiBxB;mEAErC;iEAEF;qEACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CnB,SAASJ,KAAKK,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}

package/build/safe.d.ts

@@ -1,9 +1,11 @@
 export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';
 export type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, MaybePromise, } from './types.js';
 export { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';
+export type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';
 export * as Option from './option.js';
 export * as Result from './result.js';
 export * as Iter from './iter.js';
+export * as NonEmpty from './nonempty.js';
 /**
  * Threads a value through a sequence of unary functions, left to right.
  * @param value - The initial value