@nicolastoulemont/std 0.4.0 → 0.5.0

package/dist/either-jkBX8xS1.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"either-jkBX8xS1.mjs","names":["mapped","Option.some","Option.none"],"sources":["../src/either/either.ts"],"sourcesContent":["import { FxTypeId } from \"../fx/fx.types\"\nimport { Option } from \"../option\"\nimport type { Option as OptionType } from \"../option/option.types\"\nimport { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport { dual } from \"../shared/dual\"\nimport { pipeMethod } from \"../shared/pipeable\"\nimport type {\n  Either as EitherType,\n  EitherAll,\n  EitherBimap,\n  EitherFilter,\n  EitherFlatMap,\n  EitherMap,\n  EitherMapLeft,\n  EitherMatch,\n  EitherOrElse,\n  EitherTap,\n  EitherTapLeft,\n  EitherUnwrapOr,\n  EitherUnwrapOrElse,\n} from \"./either.types\"\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create a right Either value (success/preferred path).\n *\n * By convention, right represents the correct/preferred outcome.\n * In Fx.gen(), this returns the value without short-circuiting.\n *\n * @param value - The right value\n * @returns An Either in the right state\n *\n * @example\n * ```ts\n * const result = right(42)\n * // => { right: true, value: 42 }\n *\n * // In Fx.gen() - never short-circuits\n * const fx = Fx.gen(function* () {\n *   const a = yield* Either.right(10)  // Returns 10\n *   return a * 2  // Executes, returns 20\n * })\n * ```\n */\nexport const right = <R, L = never>(value: R): EitherType<L, R> => ({\n  right: true,\n  value,\n  [FxTypeId]: {\n    _A: () => value as L | R,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  pipe: pipeMethod,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<never, R, unknown> {\n    return value\n  },\n})\n\n/**\n * Create a left Either value (alternative path).\n *\n * By convention, left represents the alternative outcome.\n * Unlike Result's err(), left doesn't imply an error - it's a valid value.\n *\n * In Fx.gen(), left returns its value without short-circuiting.\n * This is the key difference from Result.err() which short-circuits.\n *\n * @param value - The left value\n * @returns An Either in the left state\n *\n * @example\n * ```ts\n * const cached = left({ source: \"cache\", data: cachedValue })\n * // => { right: false, value: { source: \"cache\", data: cachedValue } }\n *\n * // In Fx.gen() - never short-circuits (unlike Result.err)\n * const fx = Fx.gen(function* () {\n *   const a = yield* Either.left(\"cached\")  // Returns \"cached\"\n *   return a.toUpperCase()  // Executes, returns \"CACHED\"\n * })\n * ```\n */\nexport const left = <L, R = never>(value: L): EitherType<L, R> => ({\n  right: false,\n  value,\n  [FxTypeId]: {\n    _A: () => value as L | R,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  pipe: pipeMethod,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<never, L, unknown> {\n    return value\n  },\n})\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Type guard to check if an Either is in the right state.\n *\n * @param either - The Either to check\n * @returns True if right, false if left (with type narrowing)\n *\n * @example\n * ```ts\n * const either = right(42)\n * if (isRight(either)) {\n *   console.log(either.value) // Type: number\n * }\n * ```\n */\nexport const isRight = <L, R>(either: EitherType<L, R>): either is Extract<EitherType<L, R>, { right: true }> =>\n  either.right\n\n/**\n * Type guard to check if an Either is in the left state.\n *\n * @param either - The Either to check\n * @returns True if left, false if right (with type narrowing)\n *\n * @example\n * ```ts\n * const either = left(\"error\")\n * if (isLeft(either)) {\n *   console.log(either.value) // Type: string\n * }\n * ```\n */\nexport const isLeft = <L, R>(either: EitherType<L, R>): either is Extract<EitherType<L, R>, { right: false }> =>\n  !either.right\n\n// ============================================================================\n// Right-biased Transformations\n// ============================================================================\n\n/**\n * Transform the right value of an Either.\n * Left values pass through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(either, fn)`\n * - Data-last: `pipe(either, map(fn))`\n *\n * Supports async functions.\n *\n * @param fn - Transformation function for right values\n * @returns A curried function that transforms an Either\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * map(right(5), x => x * 2) // => right(10)\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(5),\n *   map(x => x * 2)\n * ) // => right(10)\n *\n * pipe(\n *   left(\"error\"),\n *   map(x => x * 2)\n * ) // => left(\"error\")\n *\n * // Async usage\n * await pipe(\n *   right(userId),\n *   map(async id => await fetchUser(id))\n * ) // => Promise<Either<L, User>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: EitherMap = dual(2, (either: EitherType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (!either.right) return either as any\n  const mapped = fn(either.value)\n  if (mapped instanceof Promise) {\n    return mapped.then(right) as any\n  }\n  return right(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Transform the left value of an Either.\n * Right values pass through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `mapLeft(either, fn)`\n * - Data-last: `pipe(either, mapLeft(fn))`\n *\n * Supports async functions.\n *\n * @param fn - Transformation function for left values\n * @returns A curried function that transforms an Either\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * mapLeft(left(\"error\"), e => e.toUpperCase()) // => left(\"ERROR\")\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   left(\"error\"),\n *   mapLeft(e => e.toUpperCase())\n * ) // => left(\"ERROR\")\n *\n * pipe(\n *   right(42),\n *   mapLeft(e => e.toUpperCase())\n * ) // => right(42)\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const mapLeft: EitherMapLeft = dual(\n  2,\n  (either: EitherType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n    if (either.right) return either as any\n    const mapped = fn(either.value)\n    if (mapped instanceof Promise) {\n      return mapped.then(left) as any\n    }\n    return left(mapped) as any\n  },\n)\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n/**\n * Transform both sides of an Either simultaneously.\n * Unique to Either - not available in Result/Option.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `bimap(either, fnLeft, fnRight)`\n * - Data-last: `pipe(either, bimap(fnLeft, fnRight))`\n *\n * Supports async functions.\n *\n * @param fnLeft - Transformation function for left values\n * @param fnRight - Transformation function for right values\n * @returns A curried function that transforms an Either\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * bimap(right(5), e => e.toUpperCase(), x => x * 2) // => right(10)\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(5),\n *   bimap(\n *     e => e.toUpperCase(),\n *     x => x * 2\n *   )\n * ) // => right(10)\n *\n * pipe(\n *   left(\"error\"),\n *   bimap(\n *     e => e.toUpperCase(),\n *     x => x * 2\n *   )\n * ) // => left(\"ERROR\")\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const bimap: EitherBimap = dual(\n  3,\n  (either: EitherType<unknown, unknown>, fnLeft: (value: unknown) => unknown, fnRight: (value: unknown) => unknown) => {\n    if (either.right) {\n      const mapped = fnRight(either.value)\n      if (mapped instanceof Promise) {\n        return mapped.then(right) as any\n      }\n      return right(mapped) as any\n    }\n    const mapped = fnLeft(either.value)\n    if (mapped instanceof Promise) {\n      return mapped.then(left) as any\n    }\n    return left(mapped) as any\n  },\n)\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n/**\n * Chain operations that return Either.\n * Left values short-circuit the chain.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(either, fn)`\n * - Data-last: `pipe(either, flatMap(fn))`\n *\n * Supports async functions. Combines left error unions.\n *\n * @param fn - Function that returns an Either\n * @returns A curried function that chains Eithers\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * flatMap(right(5), x => right(x * 2)) // => right(10)\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(5),\n *   flatMap(x => right(x * 2)),\n *   flatMap(x => right(x + 1))\n * ) // => right(11)\n *\n * pipe(\n *   right(5),\n *   flatMap(x => left(\"error\")),\n *   flatMap(x => right(x + 1)) // Not executed\n * ) // => left(\"error\")\n *\n * // Async usage\n * await pipe(\n *   right(userId),\n *   flatMap(async id => right(await fetchUser(id))),\n *   flatMap(async user => right(await enrichProfile(user)))\n * ) // => Promise<Either<L, EnrichedUser>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const flatMap: EitherFlatMap = dual(\n  2,\n  (either: EitherType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n    if (!either.right) return either as any\n    const result = fn(either.value)\n    return result as any\n  },\n)\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n/**\n * Execute a side effect on right values without modifying the Either.\n * Left values pass through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(either, fn)`\n * - Data-last: `pipe(either, tap(fn))`\n *\n * Supports async functions.\n *\n * @param fn - Side effect function for right values\n * @returns A curried function that executes side effects\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * tap(right(42), x => console.log(x)) // Logs: 42, returns right(42)\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(42),\n *   tap(x => console.log(x)), // Logs: 42\n *   map(x => x * 2)\n * ) // => right(84)\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: EitherTap = dual(2, (either: EitherType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (!either.right) return either as any\n  const result = fn(either.value)\n  if (result instanceof Promise) {\n    return result.then(() => either) as any\n  }\n  return either as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n/**\n * Execute a side effect on left values without modifying the Either.\n * Right values pass through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tapLeft(either, fn)`\n * - Data-last: `pipe(either, tapLeft(fn))`\n *\n * Supports async functions.\n *\n * @param fn - Side effect function for left values\n * @returns A curried function that executes side effects\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * tapLeft(left(\"error\"), e => console.error(e)) // Logs: error, returns left(\"error\")\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   left(\"error\"),\n *   tapLeft(e => console.error(e)), // Logs: error\n *   mapLeft(e => e.toUpperCase())\n * ) // => left(\"ERROR\")\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tapLeft: EitherTapLeft = dual(\n  2,\n  (either: EitherType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n    if (either.right) return either as any\n    const result = fn(either.value)\n    if (result instanceof Promise) {\n      return result.then(() => either) as any\n    }\n    return either as any\n  },\n)\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n// ============================================================================\n// Recovery/Fallback\n// ============================================================================\n\n/**\n * Recover from a left value by providing an alternative Either.\n * Right values pass through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(either, fn)`\n * - Data-last: `pipe(either, orElse(fn))`\n *\n * Supports async functions. Combines right value unions.\n *\n * @param fn - Function that returns an alternative Either\n * @returns A curried function that recovers from left\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * orElse(left(\"error\"), () => right(42)) // => right(42)\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   left(\"error\"),\n *   orElse(() => right(42))\n * ) // => right(42)\n *\n * pipe(\n *   right(10),\n *   orElse(() => right(42))\n * ) // => right(10)\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const orElse: EitherOrElse = dual(2, (either: EitherType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (either.right) return either as any\n  const result = fn(either.value)\n  return result as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n/**\n * Swap left and right values.\n * Unique to Either - not available in Result/Option.\n *\n * Curried for use with pipe().\n *\n * @returns A curried function that swaps left and right\n *\n * @example\n * ```ts\n * pipe(\n *   left(\"error\"),\n *   swap()\n * ) // => right(\"error\")\n *\n * pipe(\n *   right(42),\n *   swap()\n * ) // => left(42)\n * ```\n */\nexport const swap =\n  <L, R>() =>\n  (either: EitherType<L, R>): EitherType<R, L> =>\n    either.right ? left(either.value) : right(either.value)\n\n// ============================================================================\n// Filtering\n// ============================================================================\n\n/**\n * Filter right values based on a predicate.\n * Failed predicates convert to left with onFail callback.\n * Left values pass through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(either, predicate, onFail)`\n * - Data-last: `pipe(either, filter(predicate, onFail))`\n *\n * @param predicate - Function to test right values\n * @param onFail - Function to produce left value on failure\n * @returns A curried function that filters an Either\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * filter(right(5), x => x > 3, x => `${x} is too small`) // => right(5)\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(5),\n *   filter(x => x > 3, x => `${x} is too small`)\n * ) // => right(5)\n *\n * pipe(\n *   right(2),\n *   filter(x => x > 3, x => `${x} is too small`)\n * ) // => left(\"2 is too small\")\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const filter: EitherFilter = dual(\n  3,\n  (\n    either: EitherType<unknown, unknown>,\n    predicate: (value: unknown) => boolean,\n    onFail: (value: unknown) => unknown,\n  ) => {\n    if (!either.right) return either as any\n    return predicate(either.value) ? (either as any) : left(onFail(either.value))\n  },\n)\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Eithers into a single Either.\n * Short-circuits on the first left value.\n *\n * Supports both array and object inputs with full type preservation.\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @param eithers - Array or object of Eithers to combine\n * @returns Either with all right values or first left\n *\n * @example\n * ```ts\n * // Array form - tuple types inferred automatically for up to 6 elements\n * all([right(1), right(\"hello\")])\n * // => right([1, \"hello\"])\n *\n * all([right(1), left(\"error\"), right(3)])\n * // => left(\"error\")\n *\n * // Object form\n * all({ a: right(1), b: right(\"hello\") })\n * // => right({ a: 1, b: \"hello\" })\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-assignment -- Required for handling union types in overloaded function */\nexport const all: EitherAll = (eithers: any): any => {\n  // Array case\n  if (Array.isArray(eithers)) {\n    const values: unknown[] = []\n    for (const either of eithers) {\n      if (!either.right) return either\n      values.push(either.value)\n    }\n    return right(values)\n  }\n\n  // Object case\n  const result: Record<string, unknown> = {}\n  for (const key in eithers) {\n    const either = eithers[key]\n    if (!either.right) return either\n    result[key] = either.value\n  }\n  return right(result)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-assignment */\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Extract the right value or return a default.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(either, defaultValue)`\n * - Data-last: `pipe(either, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if Either is left\n * @returns A curried function that extracts the value\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * unwrapOr(right(42), 0) // => 42\n * unwrapOr(left(\"error\"), 0) // => 0\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(42),\n *   unwrapOr(0)\n * ) // => 42\n *\n * pipe(\n *   left(\"error\"),\n *   unwrapOr(0)\n * ) // => 0\n * ```\n */\nexport const unwrapOr: EitherUnwrapOr = dual(\n  2,\n  <L, R>(either: EitherType<L, R>, defaultValue: NoInfer<R>): R => (either.right ? either.value : defaultValue),\n)\n\n/**\n * Extract the right value or compute one from the left value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(either, fn)`\n * - Data-last: `pipe(either, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute default from left value\n * @returns A curried function that extracts the value\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * unwrapOrElse(right(42), () => 0) // => 42\n * unwrapOrElse(left(\"error\"), e => e.length) // => 5\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(42),\n *   unwrapOrElse(() => 0)\n * ) // => 42\n *\n * pipe(\n *   left(\"error\"),\n *   unwrapOrElse(e => e.length)\n * ) // => 5\n * ```\n */\nexport const unwrapOrElse: EitherUnwrapOrElse = dual(\n  2,\n  <L, R>(either: EitherType<L, R>, fn: (left: L) => R): R => (either.right ? either.value : fn(either.value)),\n)\n\n/**\n * Pattern match on an Either with handlers for both cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(either, { left: ..., right: ... })`\n * - Data-last: `pipe(either, match({ left: ..., right: ... }))`\n *\n * @param handlers - Object with left and right handler functions\n * @returns A curried function that pattern matches\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * match(right(42), {\n *   left: e => `Error: ${e}`,\n *   right: x => `Success: ${x}`\n * }) // => \"Success: 42\"\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   right(42),\n *   match({\n *     left: e => `Error: ${e}`,\n *     right: x => `Success: ${x}`\n *   })\n * ) // => \"Success: 42\"\n * ```\n */\nexport const match: EitherMatch = dual(\n  2,\n  <L, R, U>(either: EitherType<L, R>, handlers: { left: (value: L) => U; right: (value: R) => U }): U =>\n    either.right ? handlers.right(either.value) : handlers.left(either.value),\n)\n\n// ============================================================================\n// Conversions\n// ============================================================================\n\n/**\n * Convert a Result to an Either.\n * Result's ok becomes right, err becomes left.\n *\n * @param result - The Result to convert\n * @returns An Either with the same semantics\n *\n * @example\n * ```ts\n * fromResult(Result.ok(42)) // => right(42)\n * fromResult(Result.err(\"error\")) // => left(\"error\")\n * ```\n */\nexport const fromResult = <R, E>(result: ResultType<R, E>): EitherType<E, R> =>\n  result.ok ? right(result.value) : left(result.error)\n\n/**\n * Convert an Either to a Result.\n * Either's right becomes ok, left becomes err.\n *\n * Curried for use with pipe().\n *\n * @param either - The Either to convert\n * @returns A Result with error semantics\n *\n * @example\n * ```ts\n * pipe(\n *   right(42),\n *   toResult\n * ) // => Result.ok(42)\n *\n * pipe(\n *   left(\"error\"),\n *   toResult\n * ) // => Result.err(\"error\")\n * ```\n */\nexport const toResult = <L, R>(either: EitherType<L, R>): ResultType<R, L> =>\n  either.right ? Result.ok(either.value) : Result.err(either.value)\n\n/**\n * Convert an Option to an Either.\n * Option's some becomes right, none becomes left with onNone callback.\n *\n * @param option - The Option to convert\n * @param onNone - Function to produce left value for none\n * @returns An Either\n *\n * @example\n * ```ts\n * fromOption(Option.some(42), () => \"not found\") // => right(42)\n * fromOption(Option.none(), () => \"not found\") // => left(\"not found\")\n * ```\n */\nexport const fromOption = <R, L>(option: OptionType<R>, onNone: () => L): EitherType<L, R> =>\n  option.some ? right(option.value) : left(onNone())\n\n/**\n * Convert an Either to an Option.\n * Either's right becomes some, left is discarded.\n *\n * Curried for use with pipe().\n *\n * @param either - The Either to convert\n * @returns An Option (left value is discarded)\n *\n * @example\n * ```ts\n * pipe(\n *   right(42),\n *   toOption\n * ) // => Option.some(42)\n *\n * pipe(\n *   left(\"error\"),\n *   toOption\n * ) // => Option.none()\n * ```\n */\nexport const toOption = <L, R>(either: EitherType<L, R>): OptionType<R> =>\n  either.right ? Option.some(either.value) : Option.none<R>()\n\n/**\n * Convert a nullable value to an Either.\n * null/undefined becomes left with onNull callback, otherwise right.\n *\n * @param value - The nullable value\n * @param onNull - Function to produce left value for null/undefined\n * @returns An Either\n *\n * @example\n * ```ts\n * fromNullable(42, () => \"not found\") // => right(42)\n * fromNullable(null, () => \"not found\") // => left(\"not found\")\n * fromNullable(undefined, () => \"not found\") // => left(\"not found\")\n * ```\n */\nexport const fromNullable = <R, L>(value: R | null | undefined, onNull: () => L): EitherType<L, R> =>\n  value === null || value === undefined ? left(onNull()) : right(value)\n\n/**\n * Create an Either from a predicate.\n * Predicate success becomes right, failure becomes left with onFail callback.\n *\n * @param value - The value to test\n * @param predicate - Function to test the value\n * @param onFail - Function to produce left value on failure\n * @returns An Either\n *\n * @example\n * ```ts\n * fromPredicate(5, x => x > 3, x => `${x} is too small`)\n * // => right(5)\n *\n * fromPredicate(2, x => x > 3, x => `${x} is too small`)\n * // => left(\"2 is too small\")\n * ```\n */\nexport const fromPredicate = <R, L>(\n  value: R,\n  predicate: (value: R) => boolean,\n  onFail: (value: R) => L,\n): EitherType<L, R> => (predicate(value) ? right(value) : left(onFail(value)))\n\n// ============================================================================\n// Namespace Export\n// ============================================================================\n\n/**\n * Either namespace containing all utility functions for working with Either types.\n *\n * Either represents a value that can be one of two types: Left<L> or Right<R>.\n * By convention, Right is the \"success\" or preferred path, while Left represents\n * an alternative outcome (not necessarily an error, unlike Result).\n *\n * Use Either when both outcomes are valid and meaningful, not just success/failure.\n * For error handling, prefer Result instead.\n *\n * @see {@link Result} for success/error semantics\n * @see {@link Option} for presence/absence semantics\n *\n * @example\n * ```ts\n * import { Either, pipe } from '@repo/std'\n * import type { Either as EitherType } from '@repo/std'\n *\n * // Either for branching logic (cache vs fresh data)\n * const fetchOrCache = (id: number): EitherType<CachedData, FreshData> =>\n *   cache.has(id) ? Either.left(cache.get(id)) : Either.right(fetch(id))\n *\n * const result = pipe(\n *   fetchOrCache(1),\n *   Either.map(data => data.value),\n *   Either.unwrapOr(defaultValue)\n * )\n *\n * // Async example\n * const processed = await pipe(\n *   Either.right(userId),\n *   Either.map(async id => await fetchUser(id)),\n *   Either.flatMap(async user => Either.right(await enrichUser(user)))\n * )\n * ```\n */\nexport const Either = {\n  // Constructors\n  left,\n  right,\n\n  // Type guards\n  isLeft,\n  isRight,\n\n  // Transformations\n  map,\n  mapLeft,\n  bimap,\n  flatMap,\n  tap,\n  tapLeft,\n\n  // Recovery\n  orElse,\n  swap,\n\n  // Filtering\n  filter,\n\n  // Combinators\n  all,\n\n  // Extraction\n  unwrapOr,\n  unwrapOrElse,\n  match,\n\n  // Conversions\n  fromResult,\n  toResult,\n  fromOption,\n  toOption,\n  fromNullable,\n  fromPredicate,\n} as const\n"],"mappings":"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"}

package/dist/equality-C2l3BIi8.mjs

@@ -1,201 +0,0 @@
-//#region src/equality/equality.ts
-const FNV_OFFSET = 2166136261;
-const FNV_PRIME = 16777619;
-/**
-* Compute a 32-bit hash code for any value using an FNV-1a inspired algorithm.
-*
-* Handles: primitives, null, undefined, Date, arrays, and plain objects.
-* Object keys are sorted for deterministic hashing regardless of insertion order.
-*
-* @param value - The value to hash (any type)
-* @returns A 32-bit unsigned integer hash code
-*
-* @example
-* ```ts
-* deepHash({ a: 1, b: 2 }) // deterministic number
-* deepHash({ b: 2, a: 1 }) // same number (keys sorted)
-* deepHash([1, 2, 3]) === deepHash([1, 2, 3]) // true
-* ```
-*/
-function deepHash(value) {
-	let hash = FNV_OFFSET;
-	if (value === null) return hash ^ 1853189228;
-	if (value === void 0) return hash ^ 1970168933;
-	switch (typeof value) {
-		case "boolean": return hash ^ (value ? 1 : 0);
-		case "number":
-			if (Number.isNaN(value)) return hash ^ 5136718;
-			if (!Number.isFinite(value)) return hash ^ (value > 0 ? 4812390 : 759787110);
-			return hash ^ (value | 0) ^ (value * 1e6 | 0);
-		case "string":
-			for (let i = 0; i < value.length; i++) {
-				hash ^= value.codePointAt(i);
-				hash = Math.imul(hash, FNV_PRIME);
-			}
-			return hash >>> 0;
-		case "object": {
-			if (value instanceof Date) return hash ^ deepHash(value.getTime());
-			if (Array.isArray(value)) {
-				hash ^= 23389;
-				for (let i = 0; i < value.length; i++) {
-					hash ^= deepHash(value[i]);
-					hash = Math.imul(hash, FNV_PRIME);
-				}
-				return hash >>> 0;
-			}
-			hash ^= 31613;
-			const obj = value;
-			const keys = Object.keys(obj).toSorted();
-			for (const key of keys) {
-				hash ^= deepHash(key);
-				hash = Math.imul(hash, FNV_PRIME);
-				hash ^= deepHash(obj[key]);
-				hash = Math.imul(hash, FNV_PRIME);
-			}
-			return hash >>> 0;
-		}
-		default: return hash;
-	}
-}
-/**
-* Deep structural equality comparison for two values.
-*
-* Compares by value rather than reference. Handles:
-* - Primitives (===)
-* - null and undefined
-* - Date objects (by timestamp)
-* - Arrays (element-wise, same length required)
-* - Plain objects (key-value pairs, same keys required)
-*
-* @param a - First value to compare
-* @param b - Second value to compare
-* @returns true if values are structurally equal
-*
-* @example
-* ```ts
-* deepEquals({ x: 1 }, { x: 1 }) // true
-* deepEquals([1, 2], [1, 2]) // true
-* deepEquals(new Date(0), new Date(0)) // true
-* deepEquals({ a: 1 }, { a: 1, b: 2 }) // false (different keys)
-* ```
-*/
-function deepEquals(a, b) {
-	if (a === b) return true;
-	if (typeof a !== typeof b) return false;
-	if (a === null || b === null) return false;
-	if (typeof a !== "object") return false;
-	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-	if (Array.isArray(a) && Array.isArray(b)) {
-		if (a.length !== b.length) return false;
-		return a.every((item, index) => deepEquals(item, b[index]));
-	}
-	if (Array.isArray(a) !== Array.isArray(b)) return false;
-	const aObj = a;
-	const bObj = b;
-	const aKeys = Object.keys(aObj);
-	const bKeys = Object.keys(bObj);
-	if (aKeys.length !== bKeys.length) return false;
-	return aKeys.every((key) => deepEquals(aObj[key], bObj[key]));
-}
-/**
-* Create an equals method for a specific record type.
-*
-* Returns a function that compares two values of the same record type.
-* Returns false if either value doesn't have the expected _tag.
-*
-* @template Tag - The discriminator string literal type
-* @template T - The record's data type (excluding _tag)
-* @param _tag - The expected _tag discriminator value
-* @returns A binary equality function for the record type
-*
-* @example
-* ```ts
-* const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')
-* equalsPoint(
-*   { _tag: 'Point', x: 1, y: 2 },
-*   { _tag: 'Point', x: 1, y: 2 }
-* ) // true
-* ```
-*/
-function createEqualsMethod(_tag) {
-	return (a, b) => {
-		if (a === b) return true;
-		if (a._tag !== _tag || b._tag !== _tag) return false;
-		return deepEquals(a, b);
-	};
-}
-/**
-* Create a hash method for a specific record type.
-*
-* Returns a function that computes a hash code for values of the record type.
-* Returns 0 if the value doesn't have the expected _tag.
-*
-* @template Tag - The discriminator string literal type
-* @template T - The record's data type (excluding _tag)
-* @param _tag - The expected _tag discriminator value
-* @returns A unary hash function for the record type
-*
-* @example
-* ```ts
-* const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')
-* hashPoint({ _tag: 'Point', x: 1, y: 2 }) // number
-* ```
-*/
-function createHashMethod(_tag) {
-	return (value) => {
-		if (value._tag !== _tag) return 0;
-		return deepHash(value);
-	};
-}
-/**
-* Create an equals method for an ADT (any variant).
-*
-* Returns a function that compares two ADT values for structural equality.
-* Values must have the same _tag and be a known variant.
-*
-* @template T - The ADT type (union of all variants with _tag)
-* @param tags - Array of valid _tag values for this ADT
-* @returns A binary equality function for any variant of the ADT
-*
-* @example
-* ```ts
-* const equalsShape = createADTEqualsMethod<Circle | Square>(['Circle', 'Square'])
-* equalsShape(circle1, circle2) // true if structurally equal
-* equalsShape(circle, square) // false (different _tag)
-* ```
-*/
-function createADTEqualsMethod(tags) {
-	return (a, b) => {
-		if (a === b) return true;
-		if (a._tag !== b._tag) return false;
-		if (!tags.includes(a._tag)) return false;
-		return deepEquals(a, b);
-	};
-}
-/**
-* Create a hash method for an ADT (any variant).
-*
-* Returns a function that computes a hash code for any variant of the ADT.
-* Returns 0 if the value's _tag is not a known variant.
-*
-* @template T - The ADT type (union of all variants with _tag)
-* @param tags - Array of valid _tag values for this ADT
-* @returns A unary hash function for any variant of the ADT
-*
-* @example
-* ```ts
-* const hashShape = createADTHashMethod<Circle | Square>(['Circle', 'Square'])
-* hashShape(circle) // number
-* hashShape(square) // number
-* ```
-*/
-function createADTHashMethod(tags) {
-	return (value) => {
-		if (!tags.includes(value._tag)) return 0;
-		return deepHash(value);
-	};
-}
-
-//#endregion
-export { deepEquals as a, createHashMethod as i, createADTHashMethod as n, deepHash as o, createEqualsMethod as r, createADTEqualsMethod as t };
-//# sourceMappingURL=equality-C2l3BIi8.mjs.map

package/dist/err-BM-svBaK.mjs

@@ -1,176 +0,0 @@
-import { t as FxTypeId } from "./fx.types-DpIQILok.mjs";
-
-//#region src/err/err.ts
-/**
-* Create a constructor function for a tagged error type.
-* If the error has no additional data, returns a function that takes no arguments.
-* If the error has data, returns a function that requires the data object.
-*
-* @template E - The tagged error type
-* @param tag - The error tag (must match E's _tag)
-* @returns A constructor function for the error type
-*
-* @example
-* ```ts
-* // Error with data
-* type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
-* const NotFound = Err.tagged<NotFoundError>("NotFoundError")
-* const err = NotFound({ resourceId: "user-123" })
-* // { _tag: "NotFoundError", resourceId: "user-123" }
-*
-* // Error without data
-* type UnauthorizedError = TaggedError<"UnauthorizedError">
-* const Unauthorized = Err.tagged<UnauthorizedError>("UnauthorizedError")
-* const err = Unauthorized()
-* // { _tag: "UnauthorizedError" }
-* ```
-*/
-const tagged = (tag) => {
-	return ((data) => ({
-		_tag: tag,
-		...data
-	}));
-};
-/**
-* Create a class-based tagged error type (Effect-style syntax).
-* Returns a class that can be extended to create custom error types.
-* Errors are native Error objects with proper stack traces and instanceof support.
-* Implements Yieldable protocol so errors can be directly yielded in Do computations.
-*
-* @template Tag - The error tag (discriminator string)
-* @param tag - The error tag
-* @returns A class that can be extended with custom data
-*
-* @example
-* ```ts
-* // Error with data
-* class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
-* const err = new NotFoundError({ id: "123" })
-* err.id // "123"
-* err._tag // "NotFoundError"
-* err.stack // Error stack trace
-*
-* // Error without data
-* class UnauthorizedError extends TaggedError("UnauthorizedError") {}
-* const err2 = new UnauthorizedError()
-*
-* // Direct yielding in Do computation
-* const program = Fx.gen(function* () {
-*   yield* new NotFoundError({ id: "123" })  // Short-circuits with error
-* })
-*
-* // instanceof checks work
-* if (err instanceof NotFoundError) {
-*   console.log(err.id)
-* }
-* ```
-*/
-function TaggedError(tag) {
-	return class TaggedErrorImpl extends Error {
-		static _tag = tag;
-		_tag = tag;
-		[FxTypeId] = {
-			_A: () => void 0,
-			_E: () => this,
-			_R: () => void 0
-		};
-		constructor(...args) {
-			super(tag);
-			this.name = tag;
-			const data = args[0];
-			if (data) Object.assign(this, data);
-			Object.setPrototypeOf(this, new.target.prototype);
-		}
-		*[Symbol.iterator]() {
-			yield this;
-			throw new Error("Unreachable: Do should short-circuit on error");
-		}
-	};
-}
-/**
-* Create a type guard for a tagged error type.
-* Returns a curried function that checks if a value is the specified error type.
-*
-* @template E - The tagged error type to check for
-* @param tag - The error tag to match
-* @returns A type guard function
-*
-* @example
-* ```ts
-* type NotFoundError = TaggedError<"NotFoundError", { id: string }>
-*
-* const error: unknown = getError()
-*
-* if (Err.is<NotFoundError>("NotFoundError")(error)) {
-*   console.log(error.id) // TypeScript knows error is NotFoundError
-* }
-*
-* // Works with union error types
-* type AppError = NotFoundError | ValidationError | DbError
-*
-* function handleError(error: AppError) {
-*   if (Err.is<NotFoundError>("NotFoundError")(error)) {
-*     // Handle not found
-*   } else if (Err.is<ValidationError>("ValidationError")(error)) {
-*     // Handle validation error
-*   }
-* }
-* ```
-*/
-const is = (tag) => {
-	return (error) => typeof error === "object" && error !== null && "_tag" in error && error._tag === tag;
-};
-/**
-* Err namespace containing utilities for creating and checking tagged errors.
-*
-* Tagged errors are plain objects with a `_tag` discriminator field,
-* making them serializable and easy to pattern match.
-*
-* @example
-* ```ts
-* import { Err, Result, Do } from "@repo/std"
-* import type { TaggedError } from "@repo/std"
-*
-* // Define error types
-* type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
-* type ValidationError = TaggedError<"ValidationError", { field: string; message: string }>
-*
-* // Create constructors
-* const NotFound = Err.tagged<NotFoundError>("NotFoundError")
-* const Validation = Err.tagged<ValidationError>("ValidationError")
-*
-* // Use with Result
-* function findUser(id: string): Result<User, NotFoundError> {
-*   const user = db.find(id)
-*   if (!user) return Result.err(NotFound({ resourceId: id }))
-*   return Result.ok(user)
-* }
-*
-* // Use with Do computation
-* const program = Fx.gen(function* () {
-*   const user = yield* findUser("123")
-*   return user
-* })
-*
-* // Pattern match on error types
-* pipe(
-*   program.run(),
-*   Result.match({
-*     ok: (user) => console.log(user),
-*     err: (error) => {
-*       if (Err.is<NotFoundError>("NotFoundError")(error)) {
-*         console.log(`Not found: ${error.resourceId}`)
-*       }
-*     }
-*   })
-* )
-* ```
-*/
-const Err = {
-	tagged,
-	is
-};
-
-//#endregion
-export { tagged as i, TaggedError as n, is as r, Err as t };
-//# sourceMappingURL=err-BM-svBaK.mjs.map

package/dist/flow-D4cE0EAg.mjs

@@ -1,28 +0,0 @@
-//#region src/shared/is-promise.ts
-/**
-* Check if a value is a Promise.
-*/
-function isPromise(value) {
-	return value instanceof Promise;
-}
-
-//#endregion
-//#region src/flow/flow.ts
-function flow(...fns) {
-	return ((...args) => {
-		let nextArgs = args;
-		for (let i = 0; i < fns.length; i++) {
-			const [result] = nextArgs = [fns[i]?.(...nextArgs)];
-			if (isPromise(result)) return resolveAsync(result, fns.slice(i + 1));
-		}
-		return nextArgs[0];
-	});
-}
-const resolveAsync = async (result, funs) => {
-	for (const fun of funs) result = fun(await result);
-	return await result;
-};
-
-//#endregion
-export { isPromise as n, flow as t };
-//# sourceMappingURL=flow-D4cE0EAg.mjs.map