@dangayle/rustlike 0.1.0

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["Ok","Err","toPanicString","Ok","Err","Ok","Err","Option","None"],"sources":["../src/async.ts","../src/match.ts","../src/types.ts","../src/interop.ts"],"sourcesContent":["/**\n * AsyncResult<T, E> - Handling asynchronous Results chaining\n */\n\nimport { Result, Ok, Err, Option } from \"./core\";\n\nexport class AsyncResult<T, E> implements PromiseLike<Result<T, E>> {\n  constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n  /**\n   * Create an AsyncResult from a Promise<Result<T, E>>\n   */\n  static fromPromise<T, E>(promise: Promise<Result<T, E>>): AsyncResult<T, E> {\n    return new AsyncResult(promise);\n  }\n\n  /**\n   * Create an AsyncResult that resolves to Ok(value)\n   */\n  static ok<T, E = never>(value: T): AsyncResult<T, E> {\n    return new AsyncResult(Promise.resolve(Ok(value)));\n  }\n\n  /**\n   * Create an AsyncResult that resolves to Err(error)\n   */\n  static err<E, T = never>(error: E): AsyncResult<T, E> {\n    return new AsyncResult(Promise.resolve(Err(error)));\n  }\n\n  /**\n   * Wrap an async function that might reject into an AsyncResult.\n   * This is the async equivalent of Result.fromThrowable().\n   *\n   * @example\n   * const result = await AsyncResult.fromThrowable(() => fetch('/api/users'));\n   * // AsyncResult<Response, unknown>\n   */\n  static fromThrowable<T, E = unknown>(fn: () => Promise<T>): AsyncResult<T, E> {\n    try {\n      return new AsyncResult(\n        fn()\n          .then((value) => Ok(value) as Result<T, E>)\n          // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n          // narrows via the E parameter (defaulting to `unknown`).\n          .catch((error: unknown) => Err(error as E) as Result<T, E>),\n      );\n    } catch (e) {\n      return new AsyncResult(Promise.resolve(Err(e as E) as Result<T, E>));\n    }\n  }\n\n  /**\n   * Map the inner Ok value using a synchronous or asynchronous function.\n   * If the function returns a Promise, it is awaited.\n   */\n  map<U>(fn: (value: T) => U | Promise<U>): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) return res as unknown as Result<U, E>;\n        // If the mapping function throws, we let Promise rejection propagate\n        // to stay consistent with sync map throwing (Rust panics on map errors).\n        const value = await fn(res.value);\n        return Ok(value);\n      }),\n    );\n  }\n\n  /**\n   * Map the inner Err value using a synchronous or asynchronous function.\n   */\n  mapErr<F>(fn: (error: E) => F | Promise<F>): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) return res as unknown as Result<T, F>;\n        const error = await fn(res.error);\n        return Err(error);\n      }),\n    );\n  }\n\n  /**\n   * Chain another Result-returning operation (sync or async).\n   * Supports returning: Result, AsyncResult, or Promise<Result>.\n   */\n  andThen<U>(\n    fn: (value: T) => Result<U, E> | AsyncResult<U, E> | Promise<Result<U, E>>,\n  ): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) return res as unknown as Result<U, E>;\n\n        const next = fn(res.value);\n        if (next instanceof AsyncResult) {\n          return await next.toPromise();\n        }\n        return await next;\n      }),\n    );\n  }\n\n  /**\n   * Handle the error case with another Result-returning operation.\n   */\n  orElse<F>(\n    fn: (error: E) => Result<T, F> | AsyncResult<T, F> | Promise<Result<T, F>>,\n  ): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) return res as unknown as Result<T, F>;\n\n        const next = fn(res.error);\n        if (next instanceof AsyncResult) {\n          return await next.toPromise();\n        }\n        return await next;\n      }),\n    );\n  }\n\n  /**\n   * Inspect the Ok value if present, without modifying it.\n   * The callback can be synchronous or asynchronous.\n   */\n  inspect(fn: (value: T) => void | Promise<void>): AsyncResult<T, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) {\n          await fn(res.value);\n        }\n        return res;\n      }),\n    );\n  }\n\n  /**\n   * Inspect the Err value if present, without modifying it.\n   * The callback can be synchronous or asynchronous.\n   */\n  inspectErr(fn: (error: E) => void | Promise<void>): AsyncResult<T, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) {\n          await fn(res.error);\n        }\n        return res;\n      }),\n    );\n  }\n\n  /**\n   * Pattern match on the result (async).\n   */\n  match<U>(handlers: {\n    ok: (value: T) => U | Promise<U>;\n    err: (error: E) => U | Promise<U>;\n  }): Promise<U> {\n    return this.promise.then((res) => res.match(handlers));\n  }\n\n  /**\n   * Unwrap the value or throw (reject).\n   */\n  async unwrap(): Promise<T> {\n    const res = await this.promise;\n    return res.unwrap();\n  }\n\n  /**\n   * Unwrap or return default.\n   */\n  async unwrapOr(defaultValue: T): Promise<T> {\n    const res = await this.promise;\n    return res.unwrapOr(defaultValue);\n  }\n\n  /**\n   * Unwrap or compute default.\n   */\n  async unwrapOrElse(fn: (error: E) => T | Promise<T>): Promise<T> {\n    const res = await this.promise;\n    if (res.isOk()) return res.value;\n    return await fn(res.error);\n  }\n\n  /**\n   * Returns true if the result is Ok and contains the given value.\n   */\n  contains(value: T): Promise<boolean> {\n    return this.promise.then((r) => r.contains(value));\n  }\n\n  /**\n   * Returns true if the result is Err and contains the given error.\n   */\n  containsErr(error: E): Promise<boolean> {\n    return this.promise.then((r) => r.containsErr(error));\n  }\n\n  /**\n   * Returns `other` if the result is Ok, otherwise returns the Err value of self.\n   */\n  and<U>(other: AsyncResult<U, E>): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then((r) =>\n        r.isOk() ? other.promise : Promise.resolve(r as unknown as Result<U, E>),\n      ),\n    );\n  }\n\n  /**\n   * Returns `other` if the result is Err, otherwise returns the Ok value of self.\n   */\n  or<F>(other: AsyncResult<T, F>): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then((r) =>\n        r.isErr() ? other.promise : Promise.resolve(r as unknown as Result<T, F>),\n      ),\n    );\n  }\n\n  /**\n   * Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.\n   */\n  flatten<U>(this: AsyncResult<Result<U, E>, E>): AsyncResult<U, E> {\n    return new AsyncResult(this.promise.then((r) => r.flatten()));\n  }\n\n  /**\n   * Converts from Result<T, E> to Option<T>, discarding the error if any.\n   */\n  toOption(): Promise<Option<T>> {\n    return this.promise.then((r) => r.toOption());\n  }\n\n  /**\n   * Converts from Result<T, E> to Option<E>, discarding the success value if any.\n   */\n  err(): Promise<Option<E>> {\n    return this.promise.then((r) => r.err());\n  }\n\n  /**\n   * Returns the contained Ok value, or throws with the provided message.\n   */\n  expect(message: string): Promise<T> {\n    return this.promise.then((r) => r.expect(message));\n  }\n\n  /**\n   * Returns the contained Err value, or throws if Ok.\n   */\n  unwrapErr(): Promise<E> {\n    return this.promise.then((r) => r.unwrapErr());\n  }\n\n  /**\n   * Returns the contained Err value, or throws with the provided message.\n   */\n  expectErr(message: string): Promise<E> {\n    return this.promise.then((r) => r.expectErr(message));\n  }\n\n  /**\n   * Get the underlying Promise<Result<T, E>>\n   */\n  toPromise(): Promise<Result<T, E>> {\n    return this.promise;\n  }\n\n  /**\n   * Implement PromiseLike to allow `await asyncResult`\n   */\n  then<TResult1 = Result<T, E>, TResult2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required by PromiseLike interface\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.promise.then(onfulfilled, onrejected);\n  }\n}\n","/**\n * Exhaustive pattern matching utilities\n *\n * Ensures all cases are handled in discriminated unions.\n */\n\nimport { toPanicString } from \"./core\";\n\n/**\n * Use in the default case of a switch to ensure exhaustiveness.\n * If the switch is not exhaustive, TypeScript will error because\n * the unhandled case type cannot be assigned to 'never'.\n *\n * @example\n * type Shape = { kind: 'circle'; radius: number } | { kind: 'rect'; w: number; h: number };\n *\n * function area(s: Shape): number {\n *   switch (s.kind) {\n *     case 'circle': return Math.PI * s.radius ** 2;\n *     case 'rect': return s.w * s.h;\n *     default: return assertNever(s);\n *   }\n * }\n */\nexport function assertNever(x: never, message?: string): never {\n  if (message) {\n    throw new Error(message);\n  }\n  throw new Error(`Unexpected value: ${toPanicString(x)}`);\n}\n\n/**\n * Type-safe exhaustive matching for discriminated unions.\n * Supports an optional catch-all '_' handler.\n *\n * @example\n * type Action =\n *   | { type: 'increment'; amount: number }\n *   | { type: 'decrement'; amount: number }\n *   | { type: 'reset' };\n *\n * const result = match(action, 'type', {\n *   increment: (a) => state + a.amount,\n *   decrement: (a) => state - a.amount,\n *   reset: () => 0,\n * });\n *\n * // With catch-all\n * const result = match(action, 'type', {\n *   increment: (a) => state + a.amount,\n *   _: () => state // catch-all\n * });\n */\nexport function match<T extends Record<K, string>, K extends keyof T, R>(\n  value: T,\n  discriminant: K,\n  handlers:\n    | { [P in T[K]]: (value: Extract<T, Record<K, P>>) => R }\n    | ({ [P in T[K]]?: (value: Extract<T, Record<K, P>>) => R } & { _: (value: T) => R }),\n): R {\n  const key = value[discriminant] as T[K];\n  const handlersRecord = handlers as Record<PropertyKey, ((value: T) => R) | undefined>;\n  const handler = handlersRecord[key];\n\n  if (handler) {\n    return handler(value);\n  }\n\n  const catchAll = handlersRecord._;\n  if (catchAll) {\n    return catchAll(value);\n  }\n\n  // This should be unreachable if types are correct\n  return assertNever(value as never, `Unhandled variant: ${key}`);\n}\n\n/**\n * Match on a discriminated union using the 'kind' discriminant (common pattern).\n *\n * @example\n * type Shape =\n *   | { kind: 'circle'; radius: number }\n *   | { kind: 'rect'; w: number; h: number };\n *\n * const area = matchKind(shape, {\n *   circle: (s) => Math.PI * s.radius ** 2,\n *   rect: (s) => s.w * s.h,\n * });\n *\n * // With catch-all\n * const isCircle = matchKind(shape, {\n *   circle: () => true,\n *   _: () => false\n * });\n */\nexport function matchKind<T extends { kind: string }, R>(\n  value: T,\n  handlers:\n    | { [P in T[\"kind\"]]: (value: Extract<T, { kind: P }>) => R }\n    | ({ [P in T[\"kind\"]]?: (value: Extract<T, { kind: P }>) => R } & { _: (value: T) => R }),\n): R {\n  return match(\n    value,\n    \"kind\",\n    handlers as { [P in T[\"kind\"]]: (value: Extract<T, Record<\"kind\", P>>) => R },\n  );\n}\n\n/**\n * Match on a discriminated union using the 'type' discriminant (common pattern).\n *\n * @example\n * type Action =\n *   | { type: 'add'; item: string }\n *   | { type: 'remove'; id: number };\n *\n * const result = matchType(action, {\n *   add: (a) => [...items, a.item],\n *   remove: (a) => items.filter((_, i) => i !== a.id),\n * });\n */\nexport function matchType<T extends { type: string }, R>(\n  value: T,\n  handlers:\n    | { [P in T[\"type\"]]: (value: Extract<T, { type: P }>) => R }\n    | ({ [P in T[\"type\"]]?: (value: Extract<T, { type: P }>) => R } & { _: (value: T) => R }),\n): R {\n  return match(\n    value,\n    \"type\",\n    handlers as { [P in T[\"type\"]]: (value: Extract<T, Record<\"type\", P>>) => R },\n  );\n}\n","/**\n * Immutability and utility types for Rust-like TypeScript\n */\n\nimport { Result, Ok, Err } from \"./core\";\n\n/**\n * Recursively make all properties readonly (deep immutability)\n */\nexport type DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : T extends Map<infer K, infer V>\n    ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>\n    : T extends Set<infer U>\n      ? ReadonlySet<DeepReadonly<U>>\n      : T extends object\n        ? { readonly [P in keyof T]: DeepReadonly<T[P]> }\n        : T;\n\n/**\n * Make specific properties readonly\n */\nexport type ReadonlyPick<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>;\n\n/**\n * Branded type for nominal typing (like Rust's newtype pattern)\n *\n * @example\n * type UserId = Brand<number, 'UserId'>;\n * type OrderId = Brand<number, 'OrderId'>;\n *\n * // These are now incompatible even though both are numbers\n * const userId: UserId = 1 as UserId;\n * const orderId: OrderId = userId; // Error!\n */\nexport type Brand<T, B> = T & { readonly __brand: B };\n\n/**\n * Create a branded type constructor\n *\n * @example\n * const UserId = brand<number, 'UserId'>();\n * const id = UserId(42); // type is Brand<number, 'UserId'>\n */\nexport const brand =\n  <T, B>() =>\n  (value: T): Brand<T, B> =>\n    value as Brand<T, B>;\n\n/**\n * NonEmpty array type - guarantees at least one element\n */\nexport type NonEmptyArray<T> = readonly [T, ...T[]];\n\n/**\n * Check if array is non-empty (type guard)\n */\nexport const isNonEmpty = <T>(arr: readonly T[]): arr is NonEmptyArray<T> => arr.length > 0;\n\n/**\n * Create a non-empty array from values\n */\nexport const nonEmpty = <T>(first: T, ...rest: T[]): NonEmptyArray<T> => [first, ...rest];\n\n/**\n * Get the first element of a non-empty array (guaranteed to exist)\n */\nexport const head = <T>(arr: NonEmptyArray<T>): T => arr[0];\n\n/**\n * Create a newtype with validation (Rust's newtype pattern + smart constructor).\n * Implements the \"parse, don't validate\" pattern - make invalid states unrepresentable.\n *\n * @example\n * const EmailAddress = newtype<string, 'Email'>(\n *   (s) => s.includes('@'),\n *   \"Invalid email\"\n * );\n *\n * const email = EmailAddress.parse(userInput);\n * // Result<Brand<string, 'Email'>, string>\n *\n * @example\n * const PositiveNumber = newtype<number, 'Positive'>(\n *   (n) => n > 0,\n *   (n) => `Expected positive, got ${n}`\n * );\n */\nexport const newtype = <T, B, E = string>(\n  validate: (value: T) => boolean,\n  error: E | ((value: T) => E),\n): {\n  parse: (value: T) => Result<Brand<T, B>, E>;\n  unsafe: (value: T) => Brand<T, B>;\n} => {\n  const getError = (value: T): E => {\n    if (typeof error === \"function\") {\n      return (error as (value: T) => E)(value);\n    }\n    return error;\n  };\n\n  return {\n    /**\n     * Parse and validate the input, returning a Result with the branded type on success.\n     */\n    parse: (value: T): Result<Brand<T, B>, E> => {\n      if (validate(value)) {\n        return Ok(value as Brand<T, B>);\n      }\n      return Err(getError(value));\n    },\n\n    /**\n     * Unsafely cast a value to the branded type without validation.\n     * Use only when you know the value is valid (e.g., from a trusted source).\n     */\n    unsafe: (value: T): Brand<T, B> => value as Brand<T, B>,\n  };\n};\n","/**\n * Interop helpers for wrapping third-party and standard library code\n */\n\nimport { Option, None, Result, Ok, Err } from \"./core\";\n\n/**\n * One-shot: wrap a single throwing operation in a Result.\n * Use {@link safeTry} to create a reusable safe wrapper instead.\n *\n * @example\n * const result = tryCatch(() => JSON.parse(userInput));\n * // Result<unknown, unknown>\n */\nexport const tryCatch = <T, E = unknown>(fn: () => T): Result<T, E> => {\n  try {\n    return Ok(fn());\n  } catch (e) {\n    // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n    // narrows via the E parameter (defaulting to `unknown`). This is safe\n    // because the caller opts into the cast by specifying E.\n    return Err(e as E);\n  }\n};\n\n/**\n * Wrap any async function that might reject to return Result\n *\n * @example\n * const result = await tryAsync(() => axios.get('/api/users'));\n * // Result<AxiosResponse, AxiosError>\n */\nexport const tryAsync = async <T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>> => {\n  try {\n    return Ok(await fn());\n  } catch (e) {\n    // Cast: see tryCatch — caller narrows E via the type parameter.\n    return Err(e as E);\n  }\n};\n\n/**\n * Create a reusable Option-returning version of any function that may return\n * T | null | undefined or throw. Returns None on null, undefined, or throw.\n *\n * @example\n * const safeFind = safeCall((id: number) => users.find(u => u.id === id));\n * const user = safeFind(42); // Option<User>\n */\nexport const safeCall =\n  <Args extends unknown[], T>(fn: (...args: Args) => T | null | undefined) =>\n  (...args: Args): Option<T> => {\n    try {\n      return Option.from(fn(...args));\n    } catch {\n      return None;\n    }\n  };\n\n/**\n * Create a reusable Option-returning version of any async function that may return\n * T | null | undefined or reject. Returns None on null, undefined, or rejection.\n *\n * @example\n * const safeFetch = safeCallAsync((url: string) => fetch(url).then(r => r.ok ? r : null));\n * const response = await safeFetch('/api'); // Option<Response>\n */\nexport const safeCallAsync =\n  <Args extends unknown[], T>(fn: (...args: Args) => Promise<T | null | undefined>) =>\n  async (...args: Args): Promise<Option<T>> => {\n    try {\n      return Option.from(await fn(...args));\n    } catch {\n      return None;\n    }\n  };\n\n/**\n * Reusable: wrap a throwing function so every call returns a Result.\n * Use {@link tryCatch} for one-shot operations instead.\n *\n * @example\n * const safeJsonParse = safeTry(JSON.parse);\n * const data = safeJsonParse(input); // Result<unknown, unknown>\n */\nexport const safeTry =\n  <Args extends unknown[], T, E = unknown>(fn: (...args: Args) => T) =>\n  (...args: Args): Result<T, E> => {\n    try {\n      return Ok(fn(...args));\n    } catch (e) {\n      // Cast: see tryCatch — caller narrows E via the type parameter.\n      return Err(e as E);\n    }\n  };\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,342 @@
+import { _ as Some, a as asyncIterFromGenerator, b as isOk, c as PeekableIter, d as iterFromGenerator, f as Err, g as Result, h as Option, i as asyncIterFromArray, l as iter, m as Ok, n as PeekableAsyncIter, o as asyncIterFromIterable, p as None, r as asyncIter, s as Iter, t as AsyncIter, u as iterFromArray, v as isErr, x as isSome, y as isNone } from "./async-iter-D7Pj6knS.cjs";
+
+//#region src/async.d.ts
+declare class AsyncResult<T, E> implements PromiseLike<Result<T, E>> {
+  private readonly promise;
+  constructor(promise: Promise<Result<T, E>>);
+  /**
+   * Create an AsyncResult from a Promise<Result<T, E>>
+   */
+  static fromPromise<T, E>(promise: Promise<Result<T, E>>): AsyncResult<T, E>;
+  /**
+   * Create an AsyncResult that resolves to Ok(value)
+   */
+  static ok<T, E = never>(value: T): AsyncResult<T, E>;
+  /**
+   * Create an AsyncResult that resolves to Err(error)
+   */
+  static err<E, T = never>(error: E): AsyncResult<T, E>;
+  /**
+   * Wrap an async function that might reject into an AsyncResult.
+   * This is the async equivalent of Result.fromThrowable().
+   *
+   * @example
+   * const result = await AsyncResult.fromThrowable(() => fetch('/api/users'));
+   * // AsyncResult<Response, unknown>
+   */
+  static fromThrowable<T, E = unknown>(fn: () => Promise<T>): AsyncResult<T, E>;
+  /**
+   * Map the inner Ok value using a synchronous or asynchronous function.
+   * If the function returns a Promise, it is awaited.
+   */
+  map<U>(fn: (value: T) => U | Promise<U>): AsyncResult<U, E>;
+  /**
+   * Map the inner Err value using a synchronous or asynchronous function.
+   */
+  mapErr<F>(fn: (error: E) => F | Promise<F>): AsyncResult<T, F>;
+  /**
+   * Chain another Result-returning operation (sync or async).
+   * Supports returning: Result, AsyncResult, or Promise<Result>.
+   */
+  andThen<U>(fn: (value: T) => Result<U, E> | AsyncResult<U, E> | Promise<Result<U, E>>): AsyncResult<U, E>;
+  /**
+   * Handle the error case with another Result-returning operation.
+   */
+  orElse<F>(fn: (error: E) => Result<T, F> | AsyncResult<T, F> | Promise<Result<T, F>>): AsyncResult<T, F>;
+  /**
+   * Inspect the Ok value if present, without modifying it.
+   * The callback can be synchronous or asynchronous.
+   */
+  inspect(fn: (value: T) => void | Promise<void>): AsyncResult<T, E>;
+  /**
+   * Inspect the Err value if present, without modifying it.
+   * The callback can be synchronous or asynchronous.
+   */
+  inspectErr(fn: (error: E) => void | Promise<void>): AsyncResult<T, E>;
+  /**
+   * Pattern match on the result (async).
+   */
+  match<U>(handlers: {
+    ok: (value: T) => U | Promise<U>;
+    err: (error: E) => U | Promise<U>;
+  }): Promise<U>;
+  /**
+   * Unwrap the value or throw (reject).
+   */
+  unwrap(): Promise<T>;
+  /**
+   * Unwrap or return default.
+   */
+  unwrapOr(defaultValue: T): Promise<T>;
+  /**
+   * Unwrap or compute default.
+   */
+  unwrapOrElse(fn: (error: E) => T | Promise<T>): Promise<T>;
+  /**
+   * Returns true if the result is Ok and contains the given value.
+   */
+  contains(value: T): Promise<boolean>;
+  /**
+   * Returns true if the result is Err and contains the given error.
+   */
+  containsErr(error: E): Promise<boolean>;
+  /**
+   * Returns `other` if the result is Ok, otherwise returns the Err value of self.
+   */
+  and<U>(other: AsyncResult<U, E>): AsyncResult<U, E>;
+  /**
+   * Returns `other` if the result is Err, otherwise returns the Ok value of self.
+   */
+  or<F>(other: AsyncResult<T, F>): AsyncResult<T, F>;
+  /**
+   * Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.
+   */
+  flatten<U>(this: AsyncResult<Result<U, E>, E>): AsyncResult<U, E>;
+  /**
+   * Converts from Result<T, E> to Option<T>, discarding the error if any.
+   */
+  toOption(): Promise<Option<T>>;
+  /**
+   * Converts from Result<T, E> to Option<E>, discarding the success value if any.
+   */
+  err(): Promise<Option<E>>;
+  /**
+   * Returns the contained Ok value, or throws with the provided message.
+   */
+  expect(message: string): Promise<T>;
+  /**
+   * Returns the contained Err value, or throws if Ok.
+   */
+  unwrapErr(): Promise<E>;
+  /**
+   * Returns the contained Err value, or throws with the provided message.
+   */
+  expectErr(message: string): Promise<E>;
+  /**
+   * Get the underlying Promise<Result<T, E>>
+   */
+  toPromise(): Promise<Result<T, E>>;
+  /**
+   * Implement PromiseLike to allow `await asyncResult`
+   */
+  then<TResult1 = Result<T, E>, TResult2 = never>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+//#endregion
+//#region src/match.d.ts
+/**
+ * Exhaustive pattern matching utilities
+ *
+ * Ensures all cases are handled in discriminated unions.
+ */
+/**
+ * Use in the default case of a switch to ensure exhaustiveness.
+ * If the switch is not exhaustive, TypeScript will error because
+ * the unhandled case type cannot be assigned to 'never'.
+ *
+ * @example
+ * type Shape = { kind: 'circle'; radius: number } | { kind: 'rect'; w: number; h: number };
+ *
+ * function area(s: Shape): number {
+ *   switch (s.kind) {
+ *     case 'circle': return Math.PI * s.radius ** 2;
+ *     case 'rect': return s.w * s.h;
+ *     default: return assertNever(s);
+ *   }
+ * }
+ */
+declare function assertNever(x: never, message?: string): never;
+/**
+ * Type-safe exhaustive matching for discriminated unions.
+ * Supports an optional catch-all '_' handler.
+ *
+ * @example
+ * type Action =
+ *   | { type: 'increment'; amount: number }
+ *   | { type: 'decrement'; amount: number }
+ *   | { type: 'reset' };
+ *
+ * const result = match(action, 'type', {
+ *   increment: (a) => state + a.amount,
+ *   decrement: (a) => state - a.amount,
+ *   reset: () => 0,
+ * });
+ *
+ * // With catch-all
+ * const result = match(action, 'type', {
+ *   increment: (a) => state + a.amount,
+ *   _: () => state // catch-all
+ * });
+ */
+declare function match<T extends Record<K, string>, K extends keyof T, R>(value: T, discriminant: K, handlers: { [P in T[K]]: (value: Extract<T, Record<K, P>>) => R } | ({ [P in T[K]]?: (value: Extract<T, Record<K, P>>) => R } & {
+  _: (value: T) => R;
+})): R;
+/**
+ * Match on a discriminated union using the 'kind' discriminant (common pattern).
+ *
+ * @example
+ * type Shape =
+ *   | { kind: 'circle'; radius: number }
+ *   | { kind: 'rect'; w: number; h: number };
+ *
+ * const area = matchKind(shape, {
+ *   circle: (s) => Math.PI * s.radius ** 2,
+ *   rect: (s) => s.w * s.h,
+ * });
+ *
+ * // With catch-all
+ * const isCircle = matchKind(shape, {
+ *   circle: () => true,
+ *   _: () => false
+ * });
+ */
+declare function matchKind<T extends {
+  kind: string;
+}, R>(value: T, handlers: { [P in T["kind"]]: (value: Extract<T, {
+  kind: P;
+}>) => R } | ({ [P in T["kind"]]?: (value: Extract<T, {
+  kind: P;
+}>) => R } & {
+  _: (value: T) => R;
+})): R;
+/**
+ * Match on a discriminated union using the 'type' discriminant (common pattern).
+ *
+ * @example
+ * type Action =
+ *   | { type: 'add'; item: string }
+ *   | { type: 'remove'; id: number };
+ *
+ * const result = matchType(action, {
+ *   add: (a) => [...items, a.item],
+ *   remove: (a) => items.filter((_, i) => i !== a.id),
+ * });
+ */
+declare function matchType<T extends {
+  type: string;
+}, R>(value: T, handlers: { [P in T["type"]]: (value: Extract<T, {
+  type: P;
+}>) => R } | ({ [P in T["type"]]?: (value: Extract<T, {
+  type: P;
+}>) => R } & {
+  _: (value: T) => R;
+})): R;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Recursively make all properties readonly (deep immutability)
+ */
+type DeepReadonly<T> = T extends (infer U)[] ? readonly DeepReadonly<U>[] : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T;
+/**
+ * Make specific properties readonly
+ */
+type ReadonlyPick<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>;
+/**
+ * Branded type for nominal typing (like Rust's newtype pattern)
+ *
+ * @example
+ * type UserId = Brand<number, 'UserId'>;
+ * type OrderId = Brand<number, 'OrderId'>;
+ *
+ * // These are now incompatible even though both are numbers
+ * const userId: UserId = 1 as UserId;
+ * const orderId: OrderId = userId; // Error!
+ */
+type Brand<T, B> = T & {
+  readonly __brand: B;
+};
+/**
+ * Create a branded type constructor
+ *
+ * @example
+ * const UserId = brand<number, 'UserId'>();
+ * const id = UserId(42); // type is Brand<number, 'UserId'>
+ */
+declare const brand: <T, B>() => (value: T) => Brand<T, B>;
+/**
+ * NonEmpty array type - guarantees at least one element
+ */
+type NonEmptyArray<T> = readonly [T, ...T[]];
+/**
+ * Check if array is non-empty (type guard)
+ */
+declare const isNonEmpty: <T>(arr: readonly T[]) => arr is NonEmptyArray<T>;
+/**
+ * Create a non-empty array from values
+ */
+declare const nonEmpty: <T>(first: T, ...rest: T[]) => NonEmptyArray<T>;
+/**
+ * Get the first element of a non-empty array (guaranteed to exist)
+ */
+declare const head: <T>(arr: NonEmptyArray<T>) => T;
+/**
+ * Create a newtype with validation (Rust's newtype pattern + smart constructor).
+ * Implements the "parse, don't validate" pattern - make invalid states unrepresentable.
+ *
+ * @example
+ * const EmailAddress = newtype<string, 'Email'>(
+ *   (s) => s.includes('@'),
+ *   "Invalid email"
+ * );
+ *
+ * const email = EmailAddress.parse(userInput);
+ * // Result<Brand<string, 'Email'>, string>
+ *
+ * @example
+ * const PositiveNumber = newtype<number, 'Positive'>(
+ *   (n) => n > 0,
+ *   (n) => `Expected positive, got ${n}`
+ * );
+ */
+declare const newtype: <T, B, E = string>(validate: (value: T) => boolean, error: E | ((value: T) => E)) => {
+  parse: (value: T) => Result<Brand<T, B>, E>;
+  unsafe: (value: T) => Brand<T, B>;
+};
+//#endregion
+//#region src/interop.d.ts
+/**
+ * One-shot: wrap a single throwing operation in a Result.
+ * Use {@link safeTry} to create a reusable safe wrapper instead.
+ *
+ * @example
+ * const result = tryCatch(() => JSON.parse(userInput));
+ * // Result<unknown, unknown>
+ */
+declare const tryCatch: <T, E = unknown>(fn: () => T) => Result<T, E>;
+/**
+ * Wrap any async function that might reject to return Result
+ *
+ * @example
+ * const result = await tryAsync(() => axios.get('/api/users'));
+ * // Result<AxiosResponse, AxiosError>
+ */
+declare const tryAsync: <T, E = unknown>(fn: () => Promise<T>) => Promise<Result<T, E>>;
+/**
+ * Create a reusable Option-returning version of any function that may return
+ * T | null | undefined or throw. Returns None on null, undefined, or throw.
+ *
+ * @example
+ * const safeFind = safeCall((id: number) => users.find(u => u.id === id));
+ * const user = safeFind(42); // Option<User>
+ */
+declare const safeCall: <Args extends unknown[], T>(fn: (...args: Args) => T | null | undefined) => (...args: Args) => Option<T>;
+/**
+ * Create a reusable Option-returning version of any async function that may return
+ * T | null | undefined or reject. Returns None on null, undefined, or rejection.
+ *
+ * @example
+ * const safeFetch = safeCallAsync((url: string) => fetch(url).then(r => r.ok ? r : null));
+ * const response = await safeFetch('/api'); // Option<Response>
+ */
+declare const safeCallAsync: <Args extends unknown[], T>(fn: (...args: Args) => Promise<T | null | undefined>) => (...args: Args) => Promise<Option<T>>;
+/**
+ * Reusable: wrap a throwing function so every call returns a Result.
+ * Use {@link tryCatch} for one-shot operations instead.
+ *
+ * @example
+ * const safeJsonParse = safeTry(JSON.parse);
+ * const data = safeJsonParse(input); // Result<unknown, unknown>
+ */
+declare const safeTry: <Args extends unknown[], T, E = unknown>(fn: (...args: Args) => T) => (...args: Args) => Result<T, E>;
+//#endregion
+export { AsyncIter, type AsyncIter as AsyncIterType, AsyncResult, type Brand, type DeepReadonly, Err, type Err as ErrType, Iter, type Iter as IterType, type NonEmptyArray, None, type None as NoneType, Ok, type Ok as OkType, Option, type Option as OptionType, type PeekableAsyncIter as PeekableAsyncIterType, type PeekableIter as PeekableIterType, type ReadonlyPick, Result, type Result as ResultType, Some, type Some as SomeType, assertNever, asyncIter, asyncIterFromArray, asyncIterFromGenerator, asyncIterFromIterable, brand, head, isErr, isNonEmpty, isNone, isOk, isSome, iter, iterFromArray, iterFromGenerator, match, matchKind, matchType, newtype, nonEmpty, safeCall, safeCallAsync, safeTry, tryAsync, tryCatch };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/async.ts","../src/match.ts","../src/types.ts","../src/interop.ts"],"mappings":"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"}