@dangayle/rustlike 0.1.0

package/dist/index.d.mts

@@ -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-1OXm1ncF.mjs";
+
+//#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.mts.map

package/dist/index.d.mts.map

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