@nicolastoulemont/std 0.2.0 → 0.4.0

package/dist/option-C2QpGffy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-C2QpGffy.mjs","names":["values"],"sources":["../src/option/option.ts"],"sourcesContent":["import { FxTypeId } from \"../fx/fx.types\"\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { pipeMethod } from \"../shared/pipeable\"\nimport { NoSuchElementError } from \"./option.types\"\nimport type {\n  Option as OptionType,\n  OptionAll,\n  OptionFlatMap,\n  OptionMap,\n  OptionMatch,\n  OptionTap,\n  OptionOrElse,\n  OptionFilter,\n  OptionUnwrapOr,\n  OptionUnwrapOrElse,\n  FromTryReturn,\n} from \"./option.types\"\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create an Option with a value.\n *\n * @param value - The value to wrap\n * @returns An Option with some: true\n *\n * @example\n * ```ts\n * some(42) // { some: true, value: 42 }\n * ```\n */\nexport const some = <T>(value: T): OptionType<T> => ({\n  some: true,\n  value,\n  [FxTypeId]: {\n    _A: () => value,\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<NoSuchElementError, T, unknown> {\n    return value\n  },\n})\n\n/**\n * Create an Option with no value.\n *\n * @returns An Option with some: false\n *\n * @example\n * ```ts\n * none() // { some: false }\n * ```\n */\nexport const none = <T = never>(): OptionType<T> => ({\n  some: false,\n  [FxTypeId]: {\n    _A: () => undefined as never,\n    _E: () => undefined as unknown as NoSuchElementError,\n    _R: () => undefined as never,\n  },\n  pipe: pipeMethod,\n  *[Symbol.iterator](): Generator<NoSuchElementError, never, unknown> {\n    yield new NoSuchElementError()\n    throw new Error(\"Unreachable: Fx.gen should short-circuit on NoSuchElementError\")\n  },\n})\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if an Option has a value.\n *\n * @param option - The Option to check\n * @returns true if the Option is some\n *\n * @example\n * ```ts\n * const option = some(42)\n * if (isSome(option)) {\n *   console.log(option.value) // TypeScript knows value exists\n * }\n * ```\n */\nexport const isSome = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { some: true }> => option.some\n\n/**\n * Check if an Option has no value.\n *\n * @param option - The Option to check\n * @returns true if the Option is none\n *\n * @example\n * ```ts\n * const option = none()\n * if (isNone(option)) {\n *   console.log('No value') // TypeScript knows value doesn't exist\n * }\n * ```\n */\nexport const isNone = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { some: false }> => !option.some\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the value of an Option.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(option, fn)`\n * - Data-last: `pipe(option, map(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function to transform the value\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * map(some(5), n => n * 2) // { some: true, value: 10 }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   some(5),\n *   map(n => n * 2)\n * ) // { some: true, value: 10 }\n *\n * // Async usage\n * await pipe(\n *   some(userId),\n *   map(async id => await fetchName(id))\n * ) // Promise<Option<string>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: OptionMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (!option.some) return option as any\n  const mapped = fn(option.value)\n  if (mapped instanceof Promise) {\n    return mapped.then(some) as any\n  }\n  return some(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Options.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(option, fn)`\n * - Data-last: `pipe(option, flatMap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that takes a value and returns an Option (or Promise<Option>)\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * const findUser = (id: number) =>\n *   id > 0 ? some({ id, name: 'Alice' }) : none()\n *\n * // Data-first (direct call)\n * flatMap(some(10), id => findUser(id))\n * // { some: true, value: { id: 10, name: 'Alice' } }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   some(10),\n *   flatMap(id => findUser(id))\n * ) // { some: true, value: { id: 10, name: 'Alice' } }\n *\n * // Async usage\n * await pipe(\n *   some(userId),\n *   flatMap(async id => some(await fetchUser(id)))\n * ) // Promise<Option<User>>\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: OptionFlatMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) =>\n  option.some ? fn(option.value) : option,\n)\n\n/**\n * Perform a side effect on the value without modifying the Option.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Option is none, the function is not called.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(option, fn)`\n * - Data-last: `pipe(option, tap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * @param fn - Function to call with the value (return value is ignored)\n * @returns A function that takes an Option and returns the same Option\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * tap(some(42), console.log) // logs 42, returns { some: true, value: 42 }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   some(42),\n *   tap(console.log),  // logs 42\n *   map(n => n * 2)\n * ) // { some: true, value: 84 }\n *\n * // Async usage\n * await pipe(\n *   some(42),\n *   tap(async v => await logToServer(v)),\n *   map(n => n * 2)\n * ) // Promise<Option<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: OptionTap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (!option.some) return option as any\n  const sideEffect = fn(option.value)\n  if (sideEffect instanceof Promise) {\n    return sideEffect.then(() => option) as any\n  }\n  return option as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from none by providing an alternative Option.\n * If the Option is some, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(option, fn)`\n * - Data-last: `pipe(option, orElse(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<T | U>\n * - Async fn: returns Promise<Option<T | U>>\n *\n * @param fn - Function that returns an alternative Option\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * orElse(none(), () => some(defaultValue))\n * // { some: true, value: defaultValue }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   none(),\n *   orElse(() => some(defaultValue))\n * ) // { some: true, value: defaultValue }\n *\n * // Async recovery\n * await pipe(\n *   none(),\n *   orElse(async () => some(await fetchFromAPI()))\n * ) // Promise<Option<T>>\n *\n * // Chain multiple fallbacks\n * pipe(\n *   none(),\n *   orElse(() => tryCache()),\n *   orElse(() => tryAPI()),\n *   orElse(() => some(fallback))\n * )\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: OptionOrElse = dual(2, (option: OptionType<unknown>, fn: () => unknown) =>\n  option.some ? option : fn(),\n)\n\n/**\n * Filter an Option based on a predicate.\n * If the predicate returns false, converts to none.\n * If the Option is already none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(option, predicate)`\n * - Data-last: `pipe(option, filter(predicate))`\n *\n * @param predicate - Function that returns true to keep the value\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * filter(some(5), n => n > 10) // { some: false }\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   some(5),\n *   filter(n => n > 10)\n * ) // { some: false }\n *\n * pipe(\n *   some(15),\n *   filter(n => n > 10)\n * ) // { some: true, value: 15 }\n *\n * // With complex validation\n * pipe(\n *   some(user),\n *   filter(u => u.age >= 18)\n * )\n * ```\n */\nexport const filter: OptionFilter = dual(2, (option: OptionType<unknown>, predicate: (value: unknown) => boolean) => {\n  if (!option.some) return option\n  return predicate(option.value) ? option : none()\n})\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Options into a single Option.\n * Supports both array and object inputs.\n *\n * - If all Options are some, returns some with all values\n * - If any Option is none, returns none (short-circuits)\n *\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @example\n * ```ts\n * // Array form - tuple types inferred automatically for up to 6 elements\n * const [num, str] = pipe(\n *   Option.all([parseNumber(input), parseString(other)]),\n *   Option.unwrapOr([0, ''])\n * )\n *\n * // Object form - returns Option<{ user: User, config: Config }>\n * pipe(\n *   Option.all({ user: findUser(id), config: loadConfig() }),\n *   Option.tap(({ user, config }) => console.log(user.name, config.theme))\n * )\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport const all: OptionAll = (options: any): any => {\n  if (Array.isArray(options)) {\n    const values: unknown[] = []\n    for (const option of options) {\n      if (!option.some) return option\n      values.push(option.value)\n    }\n    return some(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, option] of Object.entries(options)) {\n    const o = option as OptionType<unknown>\n    if (!o.some) return option\n    values[key] = o.value\n  }\n  return some(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the value or a default value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(option, defaultValue)`\n * - Data-last: `pipe(option, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if the Option is none\n * @returns A function that takes an Option and returns the value or default\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none(), 0) // 0\n *\n * // Data-last (curried for pipe)\n * pipe(some(42), unwrapOr(0)) // 42\n * pipe(none(), unwrapOr(0)) // 0\n * ```\n */\nexport const unwrapOr: OptionUnwrapOr = dual(\n  2,\n  <T>(option: OptionType<T>, defaultValue: NoInfer<T>): T => (option.some ? option.value : defaultValue),\n)\n\n/**\n * Get the value or compute a value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(option, fn)`\n * - Data-last: `pipe(option, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute a value\n * @returns A function that takes an Option and returns the value or computed value\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * unwrapOrElse(none(), () => generateDefault()) // generateDefault()\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   none(),\n *   unwrapOrElse(() => generateDefault())\n * ) // generateDefault()\n * ```\n */\nexport const unwrapOrElse: OptionUnwrapOrElse = dual(\n  2,\n  <T>(option: OptionType<T>, fn: () => T): T => (option.some ? option.value : fn()),\n)\n\n/**\n * Pattern match on an Option, handling both some and none cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(option, { some: ..., none: ... })`\n * - Data-last: `pipe(option, match({ some: ..., none: ... }))`\n *\n * @param handlers - Object with some and none handlers\n * @returns A function that takes an Option and returns the handler result\n *\n * @example\n * ```ts\n * // Data-first (direct call)\n * match(some(42), {\n *   some: n => `Got ${n}`,\n *   none: () => 'No value'\n * }) // 'Got 42'\n *\n * // Data-last (curried for pipe)\n * pipe(\n *   some(42),\n *   match({\n *     some: n => `Got ${n}`,\n *     none: () => 'No value'\n *   })\n * ) // 'Got 42'\n * ```\n */\nexport const match: OptionMatch = dual(\n  2,\n  <T, U>(option: OptionType<T>, handlers: { some: (value: T) => U; none: () => U }): U =>\n    option.some ? handlers.some(option.value) : handlers.none(),\n)\n\n// ============================================================================\n// Conversions\n// ============================================================================\n\n/**\n * Convert a nullable value to an Option.\n * null and undefined become none, other values become some.\n *\n * @param value - The value to convert\n * @returns An Option\n *\n * @example\n * ```ts\n * fromNullable(42) // { some: true, value: 42 }\n * fromNullable(null) // { some: false }\n * fromNullable(undefined) // { some: false }\n * ```\n */\nexport const fromNullable = <T>(value: T | null | undefined): OptionType<T> =>\n  value === null || value === undefined ? none<T>() : some(value)\n\n/**\n * Wrap a function that might throw into an Option.\n * Supports both sync and async functions with automatic type inference.\n *\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),\n * you should add an explicit return type annotation. This is because TypeScript's\n * conditional types cannot determine if `any` is a Promise or not, resulting in a\n * union type `Promise<Option<unknown>> | Option<any>` that won't work\n * with Option utilities like `isSome` or `isNone`.\n *\n * @param fn - Function that might throw (sync or async)\n * @returns An Option with the return value or none\n *\n * @example\n * ```ts\n * // Sync usage\n * fromTry(() => JSON.parse('{\"valid\": true}'))\n * // { some: true, value: { valid: true } }\n *\n * fromTry(() => JSON.parse('not json'))\n * // { some: false }\n *\n * // When fn returns `any`, add explicit return type:\n * fromTry((): unknown => JSON.parse(input))\n * fromTry((): MyType => JSON.parse(input))\n *\n * // Async usage\n * await fromTry(async () => await fetch('/api/user'))\n * // Promise<Option<Response>>\n *\n * await fromTry(async () => {\n *   throw new Error('network error')\n * })\n * // Promise<{ some: false }>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for conditional return type */\nexport const fromTry = <T>(fn: () => T): FromTryReturn<T> => {\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      return result.then(some).catch(() => none()) as unknown as FromTryReturn<T>\n    }\n    return some(result) as unknown as FromTryReturn<T>\n  } catch {\n    return none() as unknown as FromTryReturn<T>\n  }\n}\n\n// ============================================================================\n// Namespace\n// ============================================================================\n\n/**\n * Option namespace containing all utility functions for working with Option types.\n *\n * Option represents either the presence (some) or absence (none) of a value.\n * Use this for optional values without needing to track why the value is missing.\n *\n * @see {@link Result} for success/failure with error information\n * @see {@link Either} for two valid outcomes\n *\n * @example\n * ```ts\n * import { Option, pipe } from '@repo/std'\n * import type { Option as OptionType } from '@repo/std'\n *\n * const findUser = (id: number): OptionType<User> =>\n *   id > 0 ? Option.some({ id, name: 'Alice' }) : Option.none()\n *\n * const result = pipe(\n *   Option.some(10),\n *   Option.flatMap(findUser),\n *   Option.map(user => user.name),\n *   Option.unwrapOr('Unknown')\n * )\n * ```\n */\nexport const Option = {\n  some,\n  none,\n  isSome,\n  isNone,\n  map,\n  flatMap,\n  tap,\n  orElse,\n  filter,\n  all,\n  unwrapOr,\n  unwrapOrElse,\n  match,\n  fromNullable,\n  fromTry,\n} as const\n"],"mappings":"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"}

package/dist/option.types-BiAiZ8Ks.mjs

@@ -0,0 +1,33 @@
+import { t as FxTypeId } from "./fx.types-DpIQILok.mjs";
+
+//#region src/option/option.types.ts
+/**
+* Error thrown when attempting to access a value from None.
+* Used as the error type when Option is yielded in Fx.gen().
+*
+* When you yield* Option.none() in Fx.gen(), the computation short-circuits
+* with this error, which becomes part of the error union type.
+*
+* Implements Fx protocol so it can be yielded in Fx.gen() directly.
+*/
+var NoSuchElementError = class extends Error {
+	_tag = "NoSuchElementError";
+	[FxTypeId] = {
+		_A: () => void 0,
+		_E: () => this,
+		_R: () => void 0
+	};
+	constructor() {
+		super("Option is None - no element present");
+		this.name = "NoSuchElementError";
+	}
+};
+/**
+* Singleton None value.
+* @deprecated Use NoSuchElementError instead for Fx.gen() error handling.
+*/
+const None = { _tag: "None" };
+
+//#endregion
+export { None as n, NoSuchElementError as t };
+//# sourceMappingURL=option.types-BiAiZ8Ks.mjs.map

package/dist/option.types-BiAiZ8Ks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.types-BiAiZ8Ks.mjs","names":[],"sources":["../src/option/option.types.ts"],"sourcesContent":["import { FxTypeId } from \"../fx/fx.types\"\nimport type { Fx } from \"../fx/fx.types\"\nimport type { Pipeable } from \"../shared/pipeable\"\n\n// ============================================================================\n// NoSuchElementError\n// ============================================================================\n\n/**\n * Error thrown when attempting to access a value from None.\n * Used as the error type when Option is yielded in Fx.gen().\n *\n * When you yield* Option.none() in Fx.gen(), the computation short-circuits\n * with this error, which becomes part of the error union type.\n *\n * Implements Fx protocol so it can be yielded in Fx.gen() directly.\n */\nexport class NoSuchElementError extends Error implements Fx<never, NoSuchElementError, never> {\n  readonly _tag = \"NoSuchElementError\"\n\n  readonly [FxTypeId] = {\n    _A: () => undefined as never,\n    _E: () => this as NoSuchElementError,\n    _R: () => undefined as never,\n  }\n\n  constructor() {\n    super(\"Option is None - no element present\")\n    this.name = \"NoSuchElementError\"\n  }\n}\n\n// ============================================================================\n// None Type (legacy - kept for backward compatibility)\n// ============================================================================\n\n/**\n * Marker type for Option's absence in the Do computation context.\n * @deprecated Use NoSuchElementError instead for Fx.gen() error handling.\n */\nexport type None = { readonly _tag: \"None\" }\n\n/**\n * Singleton None value.\n * @deprecated Use NoSuchElementError instead for Fx.gen() error handling.\n */\nexport const None: None = { _tag: \"None\" }\n\n// ============================================================================\n// Option Type\n// ============================================================================\n\n/**\n * A discriminated union representing either a value (some) or absence (none).\n * Compatible with ts-pattern for exhaustive matching.\n *\n * Implements Fx protocol: Option<T> is Fx<T, NoSuchElementError, never>\n * - Yielding Some in Fx.gen() returns the value\n * - Yielding None in Fx.gen() short-circuits with NoSuchElementError\n *\n * When yielded in a generator, yields NoSuchElementError (which implements Fx)\n * for proper type inference in both gen() and Fx.gen().\n */\nexport type Option<T> = Fx<T, NoSuchElementError, never> &\n  Pipeable &\n  ({ readonly some: true; readonly value: T } | { readonly some: false }) & {\n    [Symbol.iterator](): Generator<NoSuchElementError, T, unknown>\n  }\n\n/**\n * Compute the return type of `fromTry` based on whether fn returns a Promise.\n * - If fn returns Promise<T>, result is Promise<Option<T>>\n * - If fn returns T, result is Option<T>\n */\nexport type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Option<U>> : Option<T>\n\n// ============================================================================\n// All/Combine types\n// ============================================================================\n\n/**\n * Extract the value type from an Option.\n * Uses structural matching to extract the value type from the some branch.\n */\ntype OptionValue<O> = O extends { readonly some: true; readonly value: infer T } ? T : never\n\n/**\n * Overloaded all() type with explicit tuple arities for better inference.\n * Provides tuple overloads for 1-6 elements so `as const` is not required.\n */\nexport type OptionAll = {\n  // Tuple overloads (1-6 elements)\n  <A>(options: readonly [Option<A>]): Option<[A]>\n  <A, B>(options: readonly [Option<A>, Option<B>]): Option<[A, B]>\n  <A, B, C>(options: readonly [Option<A>, Option<B>, Option<C>]): Option<[A, B, C]>\n  <A, B, C, D>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>]): Option<[A, B, C, D]>\n  <A, B, C, D, E>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>]): Option<[A, B, C, D, E]>\n  <A, B, C, D, E, F>(\n    options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>],\n  ): Option<[A, B, C, D, E, F]>\n\n  // Array fallback (longer tuples need `as const`)\n  <T extends readonly Option<unknown>[]>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>\n\n  // Object form\n  <T extends Record<string, Option<unknown>>>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>\n}\n\n// ============================================================================\n// Function Interfaces for improved pipe inference\n// ============================================================================\n\n/**\n * Interface for flatMap - using method syntax improves generic inference in pipe chains.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionFlatMap = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: (value: A) => Promise<Option<B>>): Promise<Option<B>>\n  <A, B>(option: Option<A>, fn: (value: A) => Option<B>): Option<B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: (value: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => Option<B>): (option: Option<A>) => Option<B>\n}\n\n/**\n * Interface for map function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionMap = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: (value: A) => Promise<B>): Promise<Option<B>>\n  <A, B>(option: Option<A>, fn: (value: A) => B): Option<B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: (value: A) => Promise<B>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => B): (option: Option<A>) => Option<B>\n}\n\n/**\n * Interface for tap function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionTap = {\n  // Data-first overload\n  <A, R>(option: Option<A>, fn: (value: A) => R): R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n  // Data-last overload (curried for pipe)\n  <A, R>(fn: (value: A) => R): (option: Option<A>) => R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n}\n\n/**\n * Interface for orElse function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionOrElse = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: () => Promise<Option<B>>): Promise<Option<A | B>>\n  <A, B>(option: Option<A>, fn: () => Option<B>): Option<A | B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: () => Promise<Option<B>>): (option: Option<A>) => Promise<Option<A | B>>\n  <A, B>(fn: () => Option<B>): (option: Option<A>) => Option<A | B>\n}\n\n/**\n * Interface for filter function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionFilter = {\n  // Data-first overload\n  <A>(option: Option<A>, predicate: (value: A) => boolean): Option<A>\n  // Data-last overload (curried for pipe)\n  <A>(predicate: (value: A) => boolean): (option: Option<A>) => Option<A>\n}\n\n/**\n * Interface for unwrapOr function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Uses NoInfer to prevent type inference from the default value.\n */\nexport type OptionUnwrapOr = {\n  // Data-first overload\n  <T>(option: Option<T>, defaultValue: NoInfer<T>): T\n  // Data-last overload (curried for pipe)\n  <T>(defaultValue: NoInfer<T>): (option: Option<T>) => T\n}\n\n/**\n * Interface for unwrapOrElse function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionUnwrapOrElse = {\n  // Data-first overload\n  <T>(option: Option<T>, fn: () => T): T\n  // Data-last overload (curried for pipe)\n  <T>(fn: () => T): (option: Option<T>) => T\n}\n\n/**\n * Interface for match function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionMatch = {\n  // Data-first overload\n  <T, U>(option: Option<T>, handlers: { some: (value: T) => U; none: () => U }): U\n  // Data-last overload (curried for pipe)\n  <T, U>(handlers: { some: (value: T) => U; none: () => U }): (option: Option<T>) => U\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,IAAa,qBAAb,cAAwC,MAAsD;CAC5F,AAAS,OAAO;CAEhB,CAAU,YAAY;EACpB,UAAU;EACV,UAAU;EACV,UAAU;EACX;CAED,cAAc;AACZ,QAAM,sCAAsC;AAC5C,OAAK,OAAO;;;;;;;AAkBhB,MAAa,OAAa,EAAE,MAAM,QAAQ"}

package/dist/option.types-CVvowfmd.d.mts

@@ -0,0 +1,165 @@
+import { i as Fx, l as FxTypeId } from "./fx.types-aTmhyidu.mjs";
+import { t as Pipeable } from "./pipeable-Dr0d_q4F.mjs";
+
+//#region src/option/option.types.d.ts
+
+/**
+ * Error thrown when attempting to access a value from None.
+ * Used as the error type when Option is yielded in Fx.gen().
+ *
+ * When you yield* Option.none() in Fx.gen(), the computation short-circuits
+ * with this error, which becomes part of the error union type.
+ *
+ * Implements Fx protocol so it can be yielded in Fx.gen() directly.
+ */
+declare class NoSuchElementError extends Error implements Fx<never, NoSuchElementError, never> {
+  readonly _tag = "NoSuchElementError";
+  readonly [FxTypeId]: {
+    _A: () => never;
+    _E: () => NoSuchElementError;
+    _R: () => never;
+  };
+  constructor();
+}
+/**
+ * Marker type for Option's absence in the Do computation context.
+ * @deprecated Use NoSuchElementError instead for Fx.gen() error handling.
+ */
+type None = {
+  readonly _tag: "None";
+};
+/**
+ * Singleton None value.
+ * @deprecated Use NoSuchElementError instead for Fx.gen() error handling.
+ */
+declare const None: None;
+/**
+ * A discriminated union representing either a value (some) or absence (none).
+ * Compatible with ts-pattern for exhaustive matching.
+ *
+ * Implements Fx protocol: Option<T> is Fx<T, NoSuchElementError, never>
+ * - Yielding Some in Fx.gen() returns the value
+ * - Yielding None in Fx.gen() short-circuits with NoSuchElementError
+ *
+ * When yielded in a generator, yields NoSuchElementError (which implements Fx)
+ * for proper type inference in both gen() and Fx.gen().
+ */
+type Option<T> = Fx<T, NoSuchElementError, never> & Pipeable & ({
+  readonly some: true;
+  readonly value: T;
+} | {
+  readonly some: false;
+}) & {
+  [Symbol.iterator](): Generator<NoSuchElementError, T, unknown>;
+};
+/**
+ * Compute the return type of `fromTry` based on whether fn returns a Promise.
+ * - If fn returns Promise<T>, result is Promise<Option<T>>
+ * - If fn returns T, result is Option<T>
+ */
+type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Option<U>> : Option<T>;
+/**
+ * Extract the value type from an Option.
+ * Uses structural matching to extract the value type from the some branch.
+ */
+type OptionValue<O> = O extends {
+  readonly some: true;
+  readonly value: infer T;
+} ? T : never;
+/**
+ * Overloaded all() type with explicit tuple arities for better inference.
+ * Provides tuple overloads for 1-6 elements so `as const` is not required.
+ */
+type OptionAll = {
+  <A>(options: readonly [Option<A>]): Option<[A]>;
+  <A, B>(options: readonly [Option<A>, Option<B>]): Option<[A, B]>;
+  <A, B, C>(options: readonly [Option<A>, Option<B>, Option<C>]): Option<[A, B, C]>;
+  <A, B, C, D>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>]): Option<[A, B, C, D]>;
+  <A, B, C, D, E>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>]): Option<[A, B, C, D, E]>;
+  <A, B, C, D, E, F>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>]): Option<[A, B, C, D, E, F]>;
+  <T extends readonly Option<unknown>[]>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>;
+  <T extends Record<string, Option<unknown>>>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>;
+};
+/**
+ * Interface for flatMap - using method syntax improves generic inference in pipe chains.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type OptionFlatMap = {
+  <A, B>(option: Option<A>, fn: (value: A) => Promise<Option<B>>): Promise<Option<B>>;
+  <A, B>(option: Option<A>, fn: (value: A) => Option<B>): Option<B>;
+  <A, B>(fn: (value: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>;
+  <A, B>(fn: (value: A) => Option<B>): (option: Option<A>) => Option<B>;
+};
+/**
+ * Interface for map function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type OptionMap = {
+  <A, B>(option: Option<A>, fn: (value: A) => Promise<B>): Promise<Option<B>>;
+  <A, B>(option: Option<A>, fn: (value: A) => B): Option<B>;
+  <A, B>(fn: (value: A) => Promise<B>): (option: Option<A>) => Promise<Option<B>>;
+  <A, B>(fn: (value: A) => B): (option: Option<A>) => Option<B>;
+};
+/**
+ * Interface for tap function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ */
+type OptionTap = {
+  <A, R>(option: Option<A>, fn: (value: A) => R): R extends Promise<unknown> ? Promise<Option<A>> : Option<A>;
+  <A, R>(fn: (value: A) => R): (option: Option<A>) => R extends Promise<unknown> ? Promise<Option<A>> : Option<A>;
+};
+/**
+ * Interface for orElse function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type OptionOrElse = {
+  <A, B>(option: Option<A>, fn: () => Promise<Option<B>>): Promise<Option<A | B>>;
+  <A, B>(option: Option<A>, fn: () => Option<B>): Option<A | B>;
+  <A, B>(fn: () => Promise<Option<B>>): (option: Option<A>) => Promise<Option<A | B>>;
+  <A, B>(fn: () => Option<B>): (option: Option<A>) => Option<A | B>;
+};
+/**
+ * Interface for filter function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ */
+type OptionFilter = {
+  <A>(option: Option<A>, predicate: (value: A) => boolean): Option<A>;
+  <A>(predicate: (value: A) => boolean): (option: Option<A>) => Option<A>;
+};
+/**
+ * Interface for unwrapOr function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ * Uses NoInfer to prevent type inference from the default value.
+ */
+type OptionUnwrapOr = {
+  <T>(option: Option<T>, defaultValue: NoInfer<T>): T;
+  <T>(defaultValue: NoInfer<T>): (option: Option<T>) => T;
+};
+/**
+ * Interface for unwrapOrElse function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ */
+type OptionUnwrapOrElse = {
+  <T>(option: Option<T>, fn: () => T): T;
+  <T>(fn: () => T): (option: Option<T>) => T;
+};
+/**
+ * Interface for match function.
+ * Supports both data-first and data-last (curried) calling styles via dual().
+ */
+type OptionMatch = {
+  <T, U$1>(option: Option<T>, handlers: {
+    some: (value: T) => U$1;
+    none: () => U$1;
+  }): U$1;
+  <T, U$1>(handlers: {
+    some: (value: T) => U$1;
+    none: () => U$1;
+  }): (option: Option<T>) => U$1;
+};
+//#endregion
+export { OptionAll as a, OptionMap as c, OptionTap as d, OptionUnwrapOr as f, Option as i, OptionMatch as l, NoSuchElementError as n, OptionFilter as o, OptionUnwrapOrElse as p, None as r, OptionFlatMap as s, FromTryReturn as t, OptionOrElse as u };
+//# sourceMappingURL=option.types-CVvowfmd.d.mts.map

package/dist/option.types-CVvowfmd.d.mts.map

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

package/dist/pipe/index.d.mts

@@ -1,2 +1,2 @@
-import { t as pipe } from "../index-zC2zAtZY.mjs";
+import { t as pipe } from "../index-CLlcoy8B.mjs";
 export { pipe };

package/dist/pipe/index.mjs

@@ -1,3 +1,3 @@
-import { t as pipe } from "../pipe-GYxZNkPB.mjs";
+import { t as pipe } from "../pipe-BF4G4SLo.mjs";
 
 export { pipe };

package/dist/{pipe-GYxZNkPB.mjs → pipe-BF4G4SLo.mjs}

@@ -1,4 +1,4 @@
-import { t as flow } from "./flow-pRdnqmMY.mjs";
+import { t as flow } from "./flow-D4cE0EAg.mjs";
 
 //#region src/pipe/pipe.ts
 function pipe(arg, ...fns) {
@@ -7,4 +7,4 @@ function pipe(arg, ...fns) {
 
 //#endregion
 export { pipe as t };
-//# sourceMappingURL=pipe-GYxZNkPB.mjs.map
+//# sourceMappingURL=pipe-BF4G4SLo.mjs.map

package/dist/{pipe-GYxZNkPB.mjs.map → pipe-BF4G4SLo.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"pipe-GYxZNkPB.mjs","names":[],"sources":["../src/pipe/pipe.ts"],"sourcesContent":["import { flow } from \"../flow/flow\"\nimport type { PipeReturn } from \"../pipe/pipe.types\"\nimport type { λ } from \"../shared/lambda.types\"\n\n/**\n * Like `flow` but takes an argument as its first parameter and invokes the pipe\n * with it.\n *\n * Note: unlike in `flow`, the first function of the pipe must take exactly one\n * argument.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link flow} for point-free function composition (returns a function)\n *\n * @example\n * ```typescript\n * // Type inference in action\n * pipe(\n *   2,\n *   (n) => n * 2,      // n: number (inferred from initial value)\n *   (n) => n + 1,      // n: number (inferred from previous return)\n *   (n) => n.toString() // n: number (inferred from previous return)\n * )  // -> \"5\"\n *\n * // With type transformations\n * pipe(\n *   5,\n *   (n) => n.toString(),  // number -> string\n *   (s) => s.length,      // string -> number (inferred!)\n *   (n) => n * 2          // number -> number (inferred!)\n * )\n *\n * // With async functions - Promises are automatically unwrapped\n * await pipe(\n *   5,\n *   async (n) => n * 2,   // number -> Promise<number>\n *   (n) => n.toString(),  // n: number (Promise unwrapped!)\n *   async (s) => s.length // string -> Promise<number>\n * )\n * ```\n */\n// 1 function\nexport function pipe<A, B>(arg: A, f1: (arg: A) => B): PipeReturn<[typeof f1], A>\n// 2 functions\nexport function pipe<A, B, C>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): PipeReturn<[typeof f1, typeof f2], A>\n// 3 functions\nexport function pipe<A, B, C, D>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): PipeReturn<[typeof f1, typeof f2, typeof f3], A>\n// 4 functions\nexport function pipe<A, B, C, D, E>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4], A>\n// 5 functions\nexport function pipe<A, B, C, D, E, F>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5], A>\n// 6 functions\nexport function pipe<A, B, C, D, E, F, G>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6], A>\n// 7 functions\nexport function pipe<A, B, C, D, E, F, G, H>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7], A>\n// 8 functions\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8], A>\n// 9 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9], A>\n// 10 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): PipeReturn<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10],\n  A\n>\n// 11 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ],\n  A\n>\n// 12 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ],\n  A\n>\n// 13 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ],\n  A\n>\n// 14 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ],\n  A\n>\n// 15 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ],\n  A\n>\n// Implementation signature (fallback for 16+ functions)\n// oxlint-disable-next-line no-explicit-any\nexport function pipe<A, Fns extends [(arg: A) => any, ...λ[]]>(arg: A, ...fns: Fns): PipeReturn<Fns, A> {\n  // @ts-expect-error - we want to use the any type here\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion -- Required for pipe implementation\n  return (flow(...(fns as [λ, ...λ[]])) as any)(arg)\n}\n"],"mappings":";;;AA6TA,SAAgB,KAA+C,KAAQ,GAAG,KAA8B;AAGtG,QAAQ,KAAK,GAAI,IAAoB,CAAS,IAAI"}
+{"version":3,"file":"pipe-BF4G4SLo.mjs","names":[],"sources":["../src/pipe/pipe.ts"],"sourcesContent":["import { flow } from \"../flow/flow\"\nimport type { PipeReturn } from \"../pipe/pipe.types\"\nimport type { λ } from \"../shared/lambda.types\"\n\n/**\n * Like `flow` but takes an argument as its first parameter and invokes the pipe\n * with it.\n *\n * Note: unlike in `flow`, the first function of the pipe must take exactly one\n * argument.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link flow} for point-free function composition (returns a function)\n *\n * @example\n * ```typescript\n * // Type inference in action\n * pipe(\n *   2,\n *   (n) => n * 2,      // n: number (inferred from initial value)\n *   (n) => n + 1,      // n: number (inferred from previous return)\n *   (n) => n.toString() // n: number (inferred from previous return)\n * )  // -> \"5\"\n *\n * // With type transformations\n * pipe(\n *   5,\n *   (n) => n.toString(),  // number -> string\n *   (s) => s.length,      // string -> number (inferred!)\n *   (n) => n * 2          // number -> number (inferred!)\n * )\n *\n * // With async functions - Promises are automatically unwrapped\n * await pipe(\n *   5,\n *   async (n) => n * 2,   // number -> Promise<number>\n *   (n) => n.toString(),  // n: number (Promise unwrapped!)\n *   async (s) => s.length // string -> Promise<number>\n * )\n * ```\n */\n// 1 function\nexport function pipe<A, B>(arg: A, f1: (arg: A) => B): PipeReturn<[typeof f1], A>\n// 2 functions\nexport function pipe<A, B, C>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): PipeReturn<[typeof f1, typeof f2], A>\n// 3 functions\nexport function pipe<A, B, C, D>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): PipeReturn<[typeof f1, typeof f2, typeof f3], A>\n// 4 functions\nexport function pipe<A, B, C, D, E>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4], A>\n// 5 functions\nexport function pipe<A, B, C, D, E, F>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5], A>\n// 6 functions\nexport function pipe<A, B, C, D, E, F, G>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6], A>\n// 7 functions\nexport function pipe<A, B, C, D, E, F, G, H>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7], A>\n// 8 functions\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8], A>\n// 9 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9], A>\n// 10 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): PipeReturn<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10],\n  A\n>\n// 11 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ],\n  A\n>\n// 12 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ],\n  A\n>\n// 13 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ],\n  A\n>\n// 14 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ],\n  A\n>\n// 15 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ],\n  A\n>\n// Implementation signature (fallback for 16+ functions)\n// oxlint-disable-next-line no-explicit-any\nexport function pipe<A, Fns extends [(arg: A) => any, ...λ[]]>(arg: A, ...fns: Fns): PipeReturn<Fns, A> {\n  // @ts-expect-error - we want to use the any type here\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion -- Required for pipe implementation\n  return (flow(...(fns as [λ, ...λ[]])) as any)(arg)\n}\n"],"mappings":";;;AA6TA,SAAgB,KAA+C,KAAQ,GAAG,KAA8B;AAGtG,QAAQ,KAAK,GAAI,IAAoB,CAAS,IAAI"}

package/dist/pipeable-DYNrUps7.mjs

@@ -0,0 +1,92 @@
+import { t as flow } from "./flow-D4cE0EAg.mjs";
+
+//#region src/shared/dual.ts
+/**
+* Dual function utility for creating functions that support both
+* data-first and data-last (curried) calling styles.
+*
+* This pattern is inspired by Effect's dual function implementation.
+* It enables better ergonomics by allowing direct function calls
+* without requiring pipe() for simple operations.
+*
+* @example
+* ```ts
+* // Define a dual function
+* const map = dual<
+*   <T, U>(self: Option<T>, fn: (value: T) => U) => Option<U>,
+*   <T, U>(fn: (value: T) => U) => (self: Option<T>) => Option<U>
+* >(2, (self, fn) => self.some ? some(fn(self.value)) : none())
+*
+* // Use data-first (direct call)
+* map(some(5), x => x * 2) // Option<10>
+*
+* // Use data-last (curried for pipe)
+* pipe(some(5), map(x => x * 2)) // Option<10>
+* ```
+*/
+/**
+* Creates a function that can be called with all arguments (data-first)
+* or partially applied (data-last) for use in pipe chains.
+*
+* @param arity - The number of arguments in the data-first version (including self)
+* @param body - The implementation function that receives all arguments
+* @returns A function that supports both calling styles
+*
+* @remarks
+* The arity parameter is used to determine whether the function is being
+* called in data-first mode (all arguments provided) or data-last mode
+* (partial application for piping).
+*
+* TypeScript 5.4+ NoInfer is used where appropriate in consuming code
+* to prevent inference from fallback positions.
+*/
+const dual = function(arityOrIsDataFirst, body) {
+	if (typeof arityOrIsDataFirst === "function") return function() {
+		if (arityOrIsDataFirst(arguments)) return body.apply(this, arguments);
+		return ((self) => body(self, ...arguments));
+	};
+	switch (arityOrIsDataFirst) {
+		case 0: return body;
+		case 1: return function(a) {
+			if (arguments.length > 0) return body.call(this, a);
+			return body.bind(this);
+		};
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body.call(this, a, b);
+			return (self) => body(self, a);
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body.call(this, a, b, c);
+			return (self) => body(self, a, b);
+		};
+		case 4: return function(a, b, c, d) {
+			if (arguments.length >= 4) return body.call(this, a, b, c, d);
+			return (self) => body(self, a, b, c);
+		};
+		case 5: return function(a, b, c, d, e) {
+			if (arguments.length >= 5) return body.call(this, a, b, c, d, e);
+			return (self) => body(self, a, b, c, d);
+		};
+		default: return function() {
+			if (arguments.length >= arityOrIsDataFirst) return body.apply(this, arguments);
+			const args = arguments;
+			return (self) => body(self, ...args);
+		};
+	}
+};
+
+//#endregion
+//#region src/shared/pipeable.ts
+/**
+* Create a pipe method implementation.
+* Returns a function that pipes the value through provided functions.
+* This is designed to be used as an object method, so it uses `this` binding.
+*/
+function pipeMethod(...fns) {
+	if (fns.length === 0) return this;
+	return flow(...fns)(this);
+}
+
+//#endregion
+export { dual as n, pipeMethod as t };
+//# sourceMappingURL=pipeable-DYNrUps7.mjs.map

package/dist/pipeable-DYNrUps7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeable-DYNrUps7.mjs","names":[],"sources":["../src/shared/dual.ts","../src/shared/pipeable.ts"],"sourcesContent":["/**\n * Dual function utility for creating functions that support both\n * data-first and data-last (curried) calling styles.\n *\n * This pattern is inspired by Effect's dual function implementation.\n * It enables better ergonomics by allowing direct function calls\n * without requiring pipe() for simple operations.\n *\n * @example\n * ```ts\n * // Define a dual function\n * const map = dual<\n *   <T, U>(self: Option<T>, fn: (value: T) => U) => Option<U>,\n *   <T, U>(fn: (value: T) => U) => (self: Option<T>) => Option<U>\n * >(2, (self, fn) => self.some ? some(fn(self.value)) : none())\n *\n * // Use data-first (direct call)\n * map(some(5), x => x * 2) // Option<10>\n *\n * // Use data-last (curried for pipe)\n * pipe(some(5), map(x => x * 2)) // Option<10>\n * ```\n */\n\n/**\n * Creates a function that can be called with all arguments (data-first)\n * or partially applied (data-last) for use in pipe chains.\n *\n * @param arity - The number of arguments in the data-first version (including self)\n * @param body - The implementation function that receives all arguments\n * @returns A function that supports both calling styles\n *\n * @remarks\n * The arity parameter is used to determine whether the function is being\n * called in data-first mode (all arguments provided) or data-last mode\n * (partial application for piping).\n *\n * TypeScript 5.4+ NoInfer is used where appropriate in consuming code\n * to prevent inference from fallback positions.\n */\n/* oxlint-disable no-explicit-any, ban-types, no-unsafe-function-type -- Required for polymorphic dual function that must accept any function type */\nexport const dual: {\n  <DataFirst extends (...args: any) => any, DataLast extends (...args: any) => any>(\n    arity: Parameters<DataFirst>[\"length\"],\n    body: DataFirst,\n  ): DataFirst & DataLast\n  <DataFirst extends (...args: any) => any, DataLast extends (...args: any) => any>(\n    isDataFirst: (args: IArguments) => boolean,\n    body: DataFirst,\n  ): DataFirst & DataLast\n} = function (arityOrIsDataFirst: number | ((args: IArguments) => boolean), body: Function) {\n  if (typeof arityOrIsDataFirst === \"function\") {\n    return function (this: unknown) {\n      // oxlint-disable-next-line prefer-rest-params\n      if (arityOrIsDataFirst(arguments)) {\n        // oxlint-disable-next-line prefer-rest-params\n        return body.apply(this, arguments)\n      }\n      // oxlint-disable-next-line prefer-rest-params\n      return ((self: unknown) => body(self, ...arguments)) as unknown\n    }\n  }\n  switch (arityOrIsDataFirst) {\n    case 0:\n      return body\n    case 1:\n      return function (this: unknown, a: unknown) {\n        if (arguments.length > 0) {\n          return body.call(this, a)\n        }\n        return body.bind(this)\n      }\n    case 2:\n      return function (this: unknown, a: unknown, b: unknown) {\n        if (arguments.length >= 2) {\n          return body.call(this, a, b)\n        }\n        return (self: unknown) => body(self, a)\n      }\n    case 3:\n      return function (this: unknown, a: unknown, b: unknown, c: unknown) {\n        if (arguments.length >= 3) {\n          return body.call(this, a, b, c)\n        }\n        return (self: unknown) => body(self, a, b)\n      }\n    case 4:\n      return function (this: unknown, a: unknown, b: unknown, c: unknown, d: unknown) {\n        if (arguments.length >= 4) {\n          return body.call(this, a, b, c, d)\n        }\n        return (self: unknown) => body(self, a, b, c)\n      }\n    case 5:\n      return function (this: unknown, a: unknown, b: unknown, c: unknown, d: unknown, e: unknown) {\n        if (arguments.length >= 5) {\n          return body.call(this, a, b, c, d, e)\n        }\n        return (self: unknown) => body(self, a, b, c, d)\n      }\n    default:\n      return function (this: unknown) {\n        // oxlint-disable-next-line prefer-rest-params\n        if (arguments.length >= arityOrIsDataFirst) {\n          // oxlint-disable-next-line prefer-rest-params\n          return body.apply(this, arguments)\n        }\n        const args = arguments\n        return (self: unknown) => body(self, ...args)\n      }\n  }\n} as any\n/* oxlint-enable no-explicit-any, ban-types, no-unsafe-function-type */\n","import { flow } from \"../flow/flow\"\n\n/**\n * Pipeable interface for fluent method chaining.\n * Enables: value.pipe(fn1, fn2, fn3) as alternative to pipe(value, fn1, fn2, fn3)\n */\nexport type Pipeable = {\n  pipe<A>(this: A): A\n  pipe<A, B>(this: A, ab: (a: A) => B): B\n  pipe<A, B, C>(this: A, ab: (a: A) => B, bc: (b: B) => C): C\n  pipe<A, B, C, D>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D\n  pipe<A, B, C, D, E>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E\n  pipe<A, B, C, D, E, F>(\n    this: 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  ): F\n  pipe<A, B, C, D, E, F, G>(\n    this: 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  ): G\n  pipe<A, B, C, D, E, F, G, H>(\n    this: 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\n  pipe<A, B, C, D, E, F, G, H, I>(\n    this: 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\n  pipe<A, B, C, D, E, F, G, H, I, J>(\n    this: 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    ij: (i: I) => J,\n  ): J\n}\n\ntype UnaryFn = (arg: unknown) => unknown\n\n/**\n * Create a pipe method implementation.\n * Returns a function that pipes the value through provided functions.\n * This is designed to be used as an object method, so it uses `this` binding.\n */\n// oxlint-disable no-explicit-any, no-this-in-exported-function\nexport function pipeMethod<A>(this: A, ...fns: UnaryFn[]): any {\n  if (fns.length === 0) return this\n  // oxlint-disable-next-line no-unsafe-return, no-unsafe-call\n  return (flow as any)(...fns)(this)\n}\n// oxlint-enable no-explicit-any, no-this-in-exported-function\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,OAST,SAAU,oBAA8D,MAAgB;AAC1F,KAAI,OAAO,uBAAuB,WAChC,QAAO,WAAyB;AAE9B,MAAI,mBAAmB,UAAU,CAE/B,QAAO,KAAK,MAAM,MAAM,UAAU;AAGpC,WAAS,SAAkB,KAAK,MAAM,GAAG,UAAU;;AAGvD,SAAQ,oBAAR;EACE,KAAK,EACH,QAAO;EACT,KAAK,EACH,QAAO,SAAyB,GAAY;AAC1C,OAAI,UAAU,SAAS,EACrB,QAAO,KAAK,KAAK,MAAM,EAAE;AAE3B,UAAO,KAAK,KAAK,KAAK;;EAE1B,KAAK,EACH,QAAO,SAAyB,GAAY,GAAY;AACtD,OAAI,UAAU,UAAU,EACtB,QAAO,KAAK,KAAK,MAAM,GAAG,EAAE;AAE9B,WAAQ,SAAkB,KAAK,MAAM,EAAE;;EAE3C,KAAK,EACH,QAAO,SAAyB,GAAY,GAAY,GAAY;AAClE,OAAI,UAAU,UAAU,EACtB,QAAO,KAAK,KAAK,MAAM,GAAG,GAAG,EAAE;AAEjC,WAAQ,SAAkB,KAAK,MAAM,GAAG,EAAE;;EAE9C,KAAK,EACH,QAAO,SAAyB,GAAY,GAAY,GAAY,GAAY;AAC9E,OAAI,UAAU,UAAU,EACtB,QAAO,KAAK,KAAK,MAAM,GAAG,GAAG,GAAG,EAAE;AAEpC,WAAQ,SAAkB,KAAK,MAAM,GAAG,GAAG,EAAE;;EAEjD,KAAK,EACH,QAAO,SAAyB,GAAY,GAAY,GAAY,GAAY,GAAY;AAC1F,OAAI,UAAU,UAAU,EACtB,QAAO,KAAK,KAAK,MAAM,GAAG,GAAG,GAAG,GAAG,EAAE;AAEvC,WAAQ,SAAkB,KAAK,MAAM,GAAG,GAAG,GAAG,EAAE;;EAEpD,QACE,QAAO,WAAyB;AAE9B,OAAI,UAAU,UAAU,mBAEtB,QAAO,KAAK,MAAM,MAAM,UAAU;GAEpC,MAAM,OAAO;AACb,WAAQ,SAAkB,KAAK,MAAM,GAAG,KAAK;;;;;;;;;;;;ACpCrD,SAAgB,WAAuB,GAAG,KAAqB;AAC7D,KAAI,IAAI,WAAW,EAAG,QAAO;AAE7B,QAAQ,KAAa,GAAG,IAAI,CAAC,KAAK"}

package/dist/pipeable-Dr0d_q4F.d.mts

@@ -0,0 +1,27 @@
+//#region src/shared/pipeable.d.ts
+/**
+ * Pipeable interface for fluent method chaining.
+ * Enables: value.pipe(fn1, fn2, fn3) as alternative to pipe(value, fn1, fn2, fn3)
+ */
+type Pipeable = {
+  pipe<A>(this: A): A;
+  pipe<A, B>(this: A, ab: (a: A) => B): B;
+  pipe<A, B, C>(this: A, ab: (a: A) => B, bc: (b: B) => C): C;
+  pipe<A, B, C, D>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+  pipe<A, B, C, D, E>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+  pipe<A, B, C, D, E, F>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+  pipe<A, B, C, D, E, F, G>(this: 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;
+  pipe<A, B, C, D, E, F, G, H>(this: 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, gh: (g: G) => H): H;
+  pipe<A, B, C, D, E, F, G, H, I>(this: 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, gh: (g: G) => H, hi: (h: H) => I): I;
+  pipe<A, B, C, D, E, F, G, H, I, J>(this: 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, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
+};
+type UnaryFn = (arg: unknown) => unknown;
+/**
+ * Create a pipe method implementation.
+ * Returns a function that pipes the value through provided functions.
+ * This is designed to be used as an object method, so it uses `this` binding.
+ */
+declare function pipeMethod<A>(this: A, ...fns: UnaryFn[]): any;
+//#endregion
+export { pipeMethod as n, Pipeable as t };
+//# sourceMappingURL=pipeable-Dr0d_q4F.d.mts.map

package/dist/pipeable-Dr0d_q4F.d.mts.map

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

package/dist/predicate/index.d.mts

@@ -1,2 +1,2 @@
-import { n as Predicate$1, r as Refinement, t as Predicate } from "../index-DbfMra4p.mjs";
-export { Predicate, Predicate$1 as PredicateType, Refinement };
+import { a as constant, c as not, d as some, f as Predicate$1, i as andRefinement, l as or, n as all, o as equals, p as Refinement, r as and, s as none, t as Predicate, u as orRefinement } from "../index-USQPafrR.mjs";
+export { Predicate, Predicate$1 as PredicateType, Refinement, all, and, andRefinement, constant, equals, none, not, or, orRefinement, some };

package/dist/predicate/index.mjs

@@ -1,3 +1,3 @@
-import { t as Predicate } from "../predicate-BZkZmo-W.mjs";
+import { a as constant, c as not, d as some, i as andRefinement, l as or, n as all, o as equals, r as and, s as none, t as Predicate, u as orRefinement } from "../predicate-Dt9Qsbav.mjs";
 
-export { Predicate };
+export { Predicate, all, and, andRefinement, constant, equals, none, not, or, orRefinement, some };

package/dist/{predicate-BZkZmo-W.mjs → predicate-Dt9Qsbav.mjs}

@@ -289,5 +289,5 @@ const Predicate = {
 };
 
 //#endregion
-export { Predicate as t };
-//# sourceMappingURL=predicate-BZkZmo-W.mjs.map
+export { constant as a, not as c, some as d, andRefinement as i, or as l, all as n, equals as o, and as r, none as s, Predicate as t, orRefinement as u };
+//# sourceMappingURL=predicate-Dt9Qsbav.mjs.map

package/dist/{predicate-BZkZmo-W.mjs.map → predicate-Dt9Qsbav.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"predicate-BZkZmo-W.mjs","names":[],"sources":["../src/predicate/predicate.ts"],"sourcesContent":["import type { Predicate as PredicateType, Refinement } from \"./predicate.types\"\n\n/**\n * Negate a predicate.\n * Returns true when the original predicate returns false, and vice versa.\n *\n * @template T - The type being tested\n * @param predicate - The predicate to negate\n * @returns A new predicate that returns the opposite boolean\n *\n * @example\n * ```ts\n * const isEven = (n: number) => n % 2 === 0\n * const isOdd = Predicate.not(isEven)\n *\n * isOdd(3) // true\n * isOdd(4) // false\n *\n * // Works in filter\n * [1, 2, 3, 4].filter(Predicate.not(isEven)) // [1, 3]\n * ```\n */\nexport const not = <T>(predicate: PredicateType<T>): PredicateType<T> => {\n  return (value: T): boolean => !predicate(value)\n}\n\n/**\n * Combine predicates with logical AND.\n * Returns true only when ALL predicates return true.\n * Short-circuits on first false (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if all predicates pass\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n * const isEven = (n: number) => n % 2 === 0\n * const isLessThan100 = (n: number) => n < 100\n *\n * const isValidNumber = Predicate.and(isPositive, isEven, isLessThan100)\n *\n * isValidNumber(42) // true\n * isValidNumber(-2) // false (not positive)\n * isValidNumber(101) // false (not less than 100)\n * ```\n */\nexport const and = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (!predicate(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine predicates with logical OR.\n * Returns true when ANY predicate returns true.\n * Short-circuits on first true (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if any predicate passes\n *\n * @example\n * ```ts\n * const isZero = (n: number) => n === 0\n * const isNegative = (n: number) => n < 0\n *\n * const isNotPositive = Predicate.or(isZero, isNegative)\n *\n * isNotPositive(0) // true\n * isNotPositive(-5) // true\n * isNotPositive(5) // false\n * ```\n */\nexport const or = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (predicate(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate that tests if ALL elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if all match\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n * const allPositive = Predicate.all(isPositive)\n *\n * allPositive([1, 2, 3]) // true\n * allPositive([1, -2, 3]) // false\n * allPositive([]) // true (vacuous truth)\n *\n * // Useful for validation\n * const areAllAdults = Predicate.all((u: User) => u.age >= 18)\n * ```\n */\nexport const all = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.every(predicate)\n}\n\n/**\n * Create a predicate that tests if ANY element in an array matches.\n * Returns false for empty arrays.\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if any match\n *\n * @example\n * ```ts\n * const isNegative = (n: number) => n < 0\n * const hasNegative = Predicate.some(isNegative)\n *\n * hasNegative([1, -2, 3]) // true\n * hasNegative([1, 2, 3]) // false\n * hasNegative([]) // false\n * ```\n */\nexport const some = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.some(predicate)\n}\n\n/**\n * Create a predicate that tests if NO elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n * Equivalent to `not(some(predicate))`.\n *\n * @template T - The element type\n * @param predicate - The predicate that should NOT match any element\n * @returns A predicate that takes an array and returns true if none match\n *\n * @example\n * ```ts\n * const isNegative = (n: number) => n < 0\n * const noNegatives = Predicate.none(isNegative)\n *\n * noNegatives([1, 2, 3]) // true\n * noNegatives([1, -2, 3]) // false\n * noNegatives([]) // true (vacuous truth)\n * ```\n */\nexport const none = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => !arr.some(predicate)\n}\n\n/**\n * Combine refinements with logical AND, preserving type narrowing.\n * Use this instead of `and` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if all refinements pass\n *\n * @example\n * ```ts\n * type User = { name: string; age: number; verified?: boolean }\n * type Adult = User & { age: number } // age >= 18\n * type VerifiedAdult = Adult & { verified: true }\n *\n * const isAdult = (u: User): u is Adult => u.age >= 18\n * const isVerified = (u: User): u is User & { verified: true } => u.verified === true\n *\n * // Combined refinement preserves type narrowing\n * const isVerifiedAdult = Predicate.andRefinement<User, VerifiedAdult>(isAdult, isVerified)\n *\n * if (isVerifiedAdult(user)) {\n *   user.verified // TypeScript knows this is true\n * }\n * ```\n */\nexport const andRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (!refinement(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine refinements with logical OR, preserving type narrowing.\n * Use this instead of `or` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if any refinement passes\n *\n * @example\n * ```ts\n * const isString = (v: unknown): v is string => typeof v === \"string\"\n * const isNumber = (v: unknown): v is number => typeof v === \"number\"\n *\n * const isStringOrNumber = Predicate.orRefinement<unknown, string | number>(isString, isNumber)\n *\n * if (isStringOrNumber(value)) {\n *   // value is string | number\n * }\n * ```\n */\nexport const orRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (refinement(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate from a constant boolean value.\n * Useful for testing or as a placeholder.\n *\n * @template T - The type (can be anything)\n * @param value - The constant boolean to return\n * @returns A predicate that always returns the given value\n *\n * @example\n * ```ts\n * const alwaysTrue = Predicate.constant(true)\n * const alwaysFalse = Predicate.constant(false)\n *\n * alwaysTrue(\"anything\") // true\n * alwaysFalse(42) // false\n * ```\n */\nexport const constant = <T>(value: boolean): PredicateType<T> => {\n  return (): boolean => value\n}\n\n/**\n * Create a predicate that checks strict equality.\n *\n * @template T - The type being compared\n * @param expected - The value to compare against\n * @returns A predicate that returns true if value === expected\n *\n * @example\n * ```ts\n * const isZero = Predicate.equals(0)\n * const isHello = Predicate.equals(\"hello\")\n *\n * isZero(0) // true\n * isZero(1) // false\n *\n * // Works with references too\n * const obj = { a: 1 }\n * const isObj = Predicate.equals(obj)\n * isObj(obj) // true\n * isObj({ a: 1 }) // false (different reference)\n * ```\n */\nexport const equals = <T>(expected: T): PredicateType<T> => {\n  return (value: T): boolean => value === expected\n}\n\n/**\n * Predicate namespace containing composable boolean functions.\n *\n * Predicates are functions that test values and return booleans.\n * This namespace provides combinators to build complex predicates\n * from simple ones, with support for type guards (refinements).\n *\n * @example\n * ```ts\n * import { Predicate, pipe } from \"@repo/std\"\n *\n * // Basic predicates\n * const isPositive = (n: number) => n > 0\n * const isEven = (n: number) => n % 2 === 0\n *\n * // Combine with and/or\n * const isPositiveEven = Predicate.and(isPositive, isEven)\n * const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))\n *\n * // Array predicates\n * const allPositive = Predicate.all(isPositive)\n * const hasNegative = Predicate.some(Predicate.not(isPositive))\n *\n * // Use with filter\n * [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]\n * ```\n */\nexport const Predicate = {\n  not,\n  and,\n  or,\n  all,\n  some,\n  none,\n  andRefinement,\n  orRefinement,\n  constant,\n  equals,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,OAAU,cAAkD;AACvE,SAAQ,UAAsB,CAAC,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;AAyBjD,MAAa,OAAU,GAAG,eAA8D;AACtF,SAAQ,UAAsB;AAC5B,OAAK,MAAM,aAAa,WACtB,KAAI,CAAC,UAAU,MAAM,CAAE,QAAO;AAEhC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,MAAS,GAAG,eAA8D;AACrF,SAAQ,UAAsB;AAC5B,OAAK,MAAM,aAAa,WACtB,KAAI,UAAU,MAAM,CAAE,QAAO;AAE/B,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,OAAU,cAA6D;AAClF,SAAQ,QAA+B,IAAI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;AAqB7D,MAAa,QAAW,cAA6D;AACnF,SAAQ,QAA+B,IAAI,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;AAsB5D,MAAa,QAAW,cAA6D;AACnF,SAAQ,QAA+B,CAAC,IAAI,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B7D,MAAa,iBAAiC,GAAG,gBAA+D;AAC9G,SAAQ,UAAyB;AAC/B,OAAK,MAAM,cAAc,YACvB,KAAI,CAAC,WAAW,MAAM,CAAE,QAAO;AAEjC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,gBAAgC,GAAG,gBAA+D;AAC7G,SAAQ,UAAyB;AAC/B,OAAK,MAAM,cAAc,YACvB,KAAI,WAAW,MAAM,CAAE,QAAO;AAEhC,SAAO;;;;;;;;;;;;;;;;;;;;AAqBX,MAAa,YAAe,UAAqC;AAC/D,cAAsB;;;;;;;;;;;;;;;;;;;;;;;;AAyBxB,MAAa,UAAa,aAAkC;AAC1D,SAAQ,UAAsB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B1C,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}
+{"version":3,"file":"predicate-Dt9Qsbav.mjs","names":[],"sources":["../src/predicate/predicate.ts"],"sourcesContent":["import type { Predicate as PredicateType, Refinement } from \"./predicate.types\"\n\n/**\n * Negate a predicate.\n * Returns true when the original predicate returns false, and vice versa.\n *\n * @template T - The type being tested\n * @param predicate - The predicate to negate\n * @returns A new predicate that returns the opposite boolean\n *\n * @example\n * ```ts\n * const isEven = (n: number) => n % 2 === 0\n * const isOdd = Predicate.not(isEven)\n *\n * isOdd(3) // true\n * isOdd(4) // false\n *\n * // Works in filter\n * [1, 2, 3, 4].filter(Predicate.not(isEven)) // [1, 3]\n * ```\n */\nexport const not = <T>(predicate: PredicateType<T>): PredicateType<T> => {\n  return (value: T): boolean => !predicate(value)\n}\n\n/**\n * Combine predicates with logical AND.\n * Returns true only when ALL predicates return true.\n * Short-circuits on first false (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if all predicates pass\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n * const isEven = (n: number) => n % 2 === 0\n * const isLessThan100 = (n: number) => n < 100\n *\n * const isValidNumber = Predicate.and(isPositive, isEven, isLessThan100)\n *\n * isValidNumber(42) // true\n * isValidNumber(-2) // false (not positive)\n * isValidNumber(101) // false (not less than 100)\n * ```\n */\nexport const and = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (!predicate(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine predicates with logical OR.\n * Returns true when ANY predicate returns true.\n * Short-circuits on first true (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if any predicate passes\n *\n * @example\n * ```ts\n * const isZero = (n: number) => n === 0\n * const isNegative = (n: number) => n < 0\n *\n * const isNotPositive = Predicate.or(isZero, isNegative)\n *\n * isNotPositive(0) // true\n * isNotPositive(-5) // true\n * isNotPositive(5) // false\n * ```\n */\nexport const or = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (predicate(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate that tests if ALL elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if all match\n *\n * @example\n * ```ts\n * const isPositive = (n: number) => n > 0\n * const allPositive = Predicate.all(isPositive)\n *\n * allPositive([1, 2, 3]) // true\n * allPositive([1, -2, 3]) // false\n * allPositive([]) // true (vacuous truth)\n *\n * // Useful for validation\n * const areAllAdults = Predicate.all((u: User) => u.age >= 18)\n * ```\n */\nexport const all = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.every(predicate)\n}\n\n/**\n * Create a predicate that tests if ANY element in an array matches.\n * Returns false for empty arrays.\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if any match\n *\n * @example\n * ```ts\n * const isNegative = (n: number) => n < 0\n * const hasNegative = Predicate.some(isNegative)\n *\n * hasNegative([1, -2, 3]) // true\n * hasNegative([1, 2, 3]) // false\n * hasNegative([]) // false\n * ```\n */\nexport const some = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.some(predicate)\n}\n\n/**\n * Create a predicate that tests if NO elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n * Equivalent to `not(some(predicate))`.\n *\n * @template T - The element type\n * @param predicate - The predicate that should NOT match any element\n * @returns A predicate that takes an array and returns true if none match\n *\n * @example\n * ```ts\n * const isNegative = (n: number) => n < 0\n * const noNegatives = Predicate.none(isNegative)\n *\n * noNegatives([1, 2, 3]) // true\n * noNegatives([1, -2, 3]) // false\n * noNegatives([]) // true (vacuous truth)\n * ```\n */\nexport const none = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => !arr.some(predicate)\n}\n\n/**\n * Combine refinements with logical AND, preserving type narrowing.\n * Use this instead of `and` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if all refinements pass\n *\n * @example\n * ```ts\n * type User = { name: string; age: number; verified?: boolean }\n * type Adult = User & { age: number } // age >= 18\n * type VerifiedAdult = Adult & { verified: true }\n *\n * const isAdult = (u: User): u is Adult => u.age >= 18\n * const isVerified = (u: User): u is User & { verified: true } => u.verified === true\n *\n * // Combined refinement preserves type narrowing\n * const isVerifiedAdult = Predicate.andRefinement<User, VerifiedAdult>(isAdult, isVerified)\n *\n * if (isVerifiedAdult(user)) {\n *   user.verified // TypeScript knows this is true\n * }\n * ```\n */\nexport const andRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (!refinement(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine refinements with logical OR, preserving type narrowing.\n * Use this instead of `or` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if any refinement passes\n *\n * @example\n * ```ts\n * const isString = (v: unknown): v is string => typeof v === \"string\"\n * const isNumber = (v: unknown): v is number => typeof v === \"number\"\n *\n * const isStringOrNumber = Predicate.orRefinement<unknown, string | number>(isString, isNumber)\n *\n * if (isStringOrNumber(value)) {\n *   // value is string | number\n * }\n * ```\n */\nexport const orRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (refinement(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate from a constant boolean value.\n * Useful for testing or as a placeholder.\n *\n * @template T - The type (can be anything)\n * @param value - The constant boolean to return\n * @returns A predicate that always returns the given value\n *\n * @example\n * ```ts\n * const alwaysTrue = Predicate.constant(true)\n * const alwaysFalse = Predicate.constant(false)\n *\n * alwaysTrue(\"anything\") // true\n * alwaysFalse(42) // false\n * ```\n */\nexport const constant = <T>(value: boolean): PredicateType<T> => {\n  return (): boolean => value\n}\n\n/**\n * Create a predicate that checks strict equality.\n *\n * @template T - The type being compared\n * @param expected - The value to compare against\n * @returns A predicate that returns true if value === expected\n *\n * @example\n * ```ts\n * const isZero = Predicate.equals(0)\n * const isHello = Predicate.equals(\"hello\")\n *\n * isZero(0) // true\n * isZero(1) // false\n *\n * // Works with references too\n * const obj = { a: 1 }\n * const isObj = Predicate.equals(obj)\n * isObj(obj) // true\n * isObj({ a: 1 }) // false (different reference)\n * ```\n */\nexport const equals = <T>(expected: T): PredicateType<T> => {\n  return (value: T): boolean => value === expected\n}\n\n/**\n * Predicate namespace containing composable boolean functions.\n *\n * Predicates are functions that test values and return booleans.\n * This namespace provides combinators to build complex predicates\n * from simple ones, with support for type guards (refinements).\n *\n * @example\n * ```ts\n * import { Predicate, pipe } from \"@repo/std\"\n *\n * // Basic predicates\n * const isPositive = (n: number) => n > 0\n * const isEven = (n: number) => n % 2 === 0\n *\n * // Combine with and/or\n * const isPositiveEven = Predicate.and(isPositive, isEven)\n * const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))\n *\n * // Array predicates\n * const allPositive = Predicate.all(isPositive)\n * const hasNegative = Predicate.some(Predicate.not(isPositive))\n *\n * // Use with filter\n * [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]\n * ```\n */\nexport const Predicate = {\n  not,\n  and,\n  or,\n  all,\n  some,\n  none,\n  andRefinement,\n  orRefinement,\n  constant,\n  equals,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,OAAU,cAAkD;AACvE,SAAQ,UAAsB,CAAC,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;AAyBjD,MAAa,OAAU,GAAG,eAA8D;AACtF,SAAQ,UAAsB;AAC5B,OAAK,MAAM,aAAa,WACtB,KAAI,CAAC,UAAU,MAAM,CAAE,QAAO;AAEhC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,MAAS,GAAG,eAA8D;AACrF,SAAQ,UAAsB;AAC5B,OAAK,MAAM,aAAa,WACtB,KAAI,UAAU,MAAM,CAAE,QAAO;AAE/B,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,OAAU,cAA6D;AAClF,SAAQ,QAA+B,IAAI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;AAqB7D,MAAa,QAAW,cAA6D;AACnF,SAAQ,QAA+B,IAAI,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;AAsB5D,MAAa,QAAW,cAA6D;AACnF,SAAQ,QAA+B,CAAC,IAAI,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B7D,MAAa,iBAAiC,GAAG,gBAA+D;AAC9G,SAAQ,UAAyB;AAC/B,OAAK,MAAM,cAAc,YACvB,KAAI,CAAC,WAAW,MAAM,CAAE,QAAO;AAEjC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBX,MAAa,gBAAgC,GAAG,gBAA+D;AAC7G,SAAQ,UAAyB;AAC/B,OAAK,MAAM,cAAc,YACvB,KAAI,WAAW,MAAM,CAAE,QAAO;AAEhC,SAAO;;;;;;;;;;;;;;;;;;;;AAqBX,MAAa,YAAe,UAAqC;AAC/D,cAAsB;;;;;;;;;;;;;;;;;;;;;;;;AAyBxB,MAAa,UAAa,aAAkC;AAC1D,SAAQ,UAAsB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B1C,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/result/index.d.mts

@@ -1,3 +1,3 @@
-import { i as Result$1 } from "../result.types-Bd8a43Fg.mjs";
-import { t as Result } from "../index-BwVaI5d0.mjs";
-export { Result, Result$1 as ResultType };
+import { n as Result$1 } from "../result.types-_W95221K.mjs";
+import { a as flatMap, c as isOk, d as match, f as ok, g as unwrapOrElse, h as unwrapOr, i as filter, l as map, m as tap, n as all, o as fromTry, p as orElse, r as err, s as isErr, t as Result, u as mapErr } from "../index-D5tzehjf.mjs";
+export { Result, Result$1 as ResultType, all, err, filter, flatMap, fromTry, isErr, isOk, map, mapErr, match, ok, orElse, tap, unwrapOr, unwrapOrElse };

package/dist/result/index.mjs

@@ -1,3 +1,3 @@
-import { t as Result } from "../result-C5tPWR60.mjs";
+import { a as flatMap, c as isOk, d as match, f as ok, g as unwrapOrElse, h as unwrapOr, i as filter, l as map, m as tap, n as all, o as fromTry, p as orElse, r as err, s as isErr, t as Result, u as mapErr } from "../result-DhYA-J-M.mjs";
 
-export { Result };
+export { Result, all, err, filter, flatMap, fromTry, isErr, isOk, map, mapErr, match, ok, orElse, tap, unwrapOr, unwrapOrElse };