@dangayle/rustlike 0.1.0

package/dist/index.mjs

@@ -0,0 +1,443 @@
+import { _ as isNone, a as asyncIterFromIterable, b as toPanicString, c as iterFromArray, d as None, f as Ok, g as isErr, h as Some, i as asyncIterFromGenerator, l as iterFromGenerator, m as Result, n as asyncIter, o as Iter, p as Option, r as asyncIterFromArray, s as iter, t as AsyncIter, u as Err, v as isOk, y as isSome } from "./async-iter-aLdg-qp2.mjs";
+
+//#region src/async.ts
+/**
+* AsyncResult<T, E> - Handling asynchronous Results chaining
+*/
+var AsyncResult = class AsyncResult {
+	constructor(promise) {
+		this.promise = promise;
+	}
+	/**
+	* Create an AsyncResult from a Promise<Result<T, E>>
+	*/
+	static fromPromise(promise) {
+		return new AsyncResult(promise);
+	}
+	/**
+	* Create an AsyncResult that resolves to Ok(value)
+	*/
+	static ok(value) {
+		return new AsyncResult(Promise.resolve(Ok(value)));
+	}
+	/**
+	* Create an AsyncResult that resolves to Err(error)
+	*/
+	static err(error) {
+		return new AsyncResult(Promise.resolve(Err(error)));
+	}
+	/**
+	* 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(fn) {
+		try {
+			return new AsyncResult(fn().then((value) => Ok(value)).catch((error) => Err(error)));
+		} catch (e) {
+			return new AsyncResult(Promise.resolve(Err(e)));
+		}
+	}
+	/**
+	* Map the inner Ok value using a synchronous or asynchronous function.
+	* If the function returns a Promise, it is awaited.
+	*/
+	map(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isErr()) return res;
+			return Ok(await fn(res.value));
+		}));
+	}
+	/**
+	* Map the inner Err value using a synchronous or asynchronous function.
+	*/
+	mapErr(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isOk()) return res;
+			return Err(await fn(res.error));
+		}));
+	}
+	/**
+	* Chain another Result-returning operation (sync or async).
+	* Supports returning: Result, AsyncResult, or Promise<Result>.
+	*/
+	andThen(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isErr()) return res;
+			const next = fn(res.value);
+			if (next instanceof AsyncResult) return await next.toPromise();
+			return await next;
+		}));
+	}
+	/**
+	* Handle the error case with another Result-returning operation.
+	*/
+	orElse(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isOk()) return res;
+			const next = fn(res.error);
+			if (next instanceof AsyncResult) return await next.toPromise();
+			return await next;
+		}));
+	}
+	/**
+	* Inspect the Ok value if present, without modifying it.
+	* The callback can be synchronous or asynchronous.
+	*/
+	inspect(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isOk()) await fn(res.value);
+			return res;
+		}));
+	}
+	/**
+	* Inspect the Err value if present, without modifying it.
+	* The callback can be synchronous or asynchronous.
+	*/
+	inspectErr(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isErr()) await fn(res.error);
+			return res;
+		}));
+	}
+	/**
+	* Pattern match on the result (async).
+	*/
+	match(handlers) {
+		return this.promise.then((res) => res.match(handlers));
+	}
+	/**
+	* Unwrap the value or throw (reject).
+	*/
+	async unwrap() {
+		return (await this.promise).unwrap();
+	}
+	/**
+	* Unwrap or return default.
+	*/
+	async unwrapOr(defaultValue) {
+		return (await this.promise).unwrapOr(defaultValue);
+	}
+	/**
+	* Unwrap or compute default.
+	*/
+	async unwrapOrElse(fn) {
+		const res = await this.promise;
+		if (res.isOk()) return res.value;
+		return await fn(res.error);
+	}
+	/**
+	* Returns true if the result is Ok and contains the given value.
+	*/
+	contains(value) {
+		return this.promise.then((r) => r.contains(value));
+	}
+	/**
+	* Returns true if the result is Err and contains the given error.
+	*/
+	containsErr(error) {
+		return this.promise.then((r) => r.containsErr(error));
+	}
+	/**
+	* Returns `other` if the result is Ok, otherwise returns the Err value of self.
+	*/
+	and(other) {
+		return new AsyncResult(this.promise.then((r) => r.isOk() ? other.promise : Promise.resolve(r)));
+	}
+	/**
+	* Returns `other` if the result is Err, otherwise returns the Ok value of self.
+	*/
+	or(other) {
+		return new AsyncResult(this.promise.then((r) => r.isErr() ? other.promise : Promise.resolve(r)));
+	}
+	/**
+	* Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.
+	*/
+	flatten() {
+		return new AsyncResult(this.promise.then((r) => r.flatten()));
+	}
+	/**
+	* Converts from Result<T, E> to Option<T>, discarding the error if any.
+	*/
+	toOption() {
+		return this.promise.then((r) => r.toOption());
+	}
+	/**
+	* Converts from Result<T, E> to Option<E>, discarding the success value if any.
+	*/
+	err() {
+		return this.promise.then((r) => r.err());
+	}
+	/**
+	* Returns the contained Ok value, or throws with the provided message.
+	*/
+	expect(message) {
+		return this.promise.then((r) => r.expect(message));
+	}
+	/**
+	* Returns the contained Err value, or throws if Ok.
+	*/
+	unwrapErr() {
+		return this.promise.then((r) => r.unwrapErr());
+	}
+	/**
+	* Returns the contained Err value, or throws with the provided message.
+	*/
+	expectErr(message) {
+		return this.promise.then((r) => r.expectErr(message));
+	}
+	/**
+	* Get the underlying Promise<Result<T, E>>
+	*/
+	toPromise() {
+		return this.promise;
+	}
+	/**
+	* Implement PromiseLike to allow `await asyncResult`
+	*/
+	then(onfulfilled, onrejected) {
+		return this.promise.then(onfulfilled, onrejected);
+	}
+};
+
+//#endregion
+//#region src/match.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);
+*   }
+* }
+*/
+function assertNever(x, message) {
+	if (message) throw new Error(message);
+	throw new Error(`Unexpected value: ${toPanicString(x)}`);
+}
+/**
+* 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
+* });
+*/
+function match(value, discriminant, handlers) {
+	const key = value[discriminant];
+	const handlersRecord = handlers;
+	const handler = handlersRecord[key];
+	if (handler) return handler(value);
+	const catchAll = handlersRecord._;
+	if (catchAll) return catchAll(value);
+	return assertNever(value, `Unhandled variant: ${key}`);
+}
+/**
+* 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
+* });
+*/
+function matchKind(value, handlers) {
+	return match(value, "kind", handlers);
+}
+/**
+* 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),
+* });
+*/
+function matchType(value, handlers) {
+	return match(value, "type", handlers);
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* Immutability and utility types for Rust-like TypeScript
+*/
+/**
+* Create a branded type constructor
+*
+* @example
+* const UserId = brand<number, 'UserId'>();
+* const id = UserId(42); // type is Brand<number, 'UserId'>
+*/
+const brand = () => (value) => value;
+/**
+* Check if array is non-empty (type guard)
+*/
+const isNonEmpty = (arr) => arr.length > 0;
+/**
+* Create a non-empty array from values
+*/
+const nonEmpty = (first, ...rest) => [first, ...rest];
+/**
+* Get the first element of a non-empty array (guaranteed to exist)
+*/
+const head = (arr) => arr[0];
+/**
+* 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}`
+* );
+*/
+const newtype = (validate, error) => {
+	const getError = (value) => {
+		if (typeof error === "function") return error(value);
+		return error;
+	};
+	return {
+		parse: (value) => {
+			if (validate(value)) return Ok(value);
+			return Err(getError(value));
+		},
+		unsafe: (value) => value
+	};
+};
+
+//#endregion
+//#region src/interop.ts
+/**
+* Interop helpers for wrapping third-party and standard library code
+*/
+/**
+* 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>
+*/
+const tryCatch = (fn) => {
+	try {
+		return Ok(fn());
+	} catch (e) {
+		return Err(e);
+	}
+};
+/**
+* Wrap any async function that might reject to return Result
+*
+* @example
+* const result = await tryAsync(() => axios.get('/api/users'));
+* // Result<AxiosResponse, AxiosError>
+*/
+const tryAsync = async (fn) => {
+	try {
+		return Ok(await fn());
+	} catch (e) {
+		return Err(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>
+*/
+const safeCall = (fn) => (...args) => {
+	try {
+		return Option.from(fn(...args));
+	} catch {
+		return None;
+	}
+};
+/**
+* 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>
+*/
+const safeCallAsync = (fn) => async (...args) => {
+	try {
+		return Option.from(await fn(...args));
+	} catch {
+		return None;
+	}
+};
+/**
+* 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>
+*/
+const safeTry = (fn) => (...args) => {
+	try {
+		return Ok(fn(...args));
+	} catch (e) {
+		return Err(e);
+	}
+};
+
+//#endregion
+export { AsyncIter, AsyncResult, Err, Iter, None, Ok, Option, Result, Some, 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.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"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/node.cjs

@@ -0,0 +1,118 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_async_iter = require('./async-iter-3iu4aRtf.cjs');
+let fs = require("fs");
+fs = __toESM(fs);
+let readline = require("readline");
+readline = __toESM(readline);
+
+//#region src/node.ts
+/**
+* Node.js-specific utilities for rustlike.
+*
+* This module contains functions that depend on Node.js built-in modules
+* (fs, readline) and should only be imported in Node.js environments.
+* Browser and edge runtime consumers should use the main 'rustlike' entry point.
+*
+* Import from 'rustlike/node' to access these functions.
+*/
+/**
+* Create an Iter that lazily reads lines from a file.
+* Uses Node.js fs.readFileSync but yields lines lazily via generator.
+*
+* Note: This reads the entire file into memory but yields lines lazily.
+* For truly streaming line-by-line reading, use asyncIterLines.
+*
+* @param filepath - Path to the file to read
+* @returns Result with Iter<string> on success, error message on failure
+*
+* @example
+* const lines = iterLinesSync('data.txt');
+* lines.match({
+*   ok: (iter) => iter.skip(1).map(parseLine).collect(),
+*   err: (e) => console.error(e)
+* });
+*/
+function iterLinesSync(filepath) {
+	try {
+		const lines = fs.readFileSync(filepath, "utf-8").split("\n");
+		if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+		return require_async_iter.Ok(require_async_iter.iter(lines));
+	} catch (error) {
+		if (error instanceof Error) return require_async_iter.Err(`Failed to read file '${filepath}': ${error.message}`);
+		return require_async_iter.Err(`Failed to read file '${filepath}': ${String(error)}`);
+	}
+}
+/**
+* Create an AsyncIter that reads lines from a file using streaming.
+* Truly memory-efficient - reads lines on-demand without loading entire file.
+*
+* Uses Node.js readline with createReadStream for efficient streaming.
+*
+* @param filepath - Path to the file to read
+* @returns Promise of Result with AsyncIter<string> on success, error message on failure
+*
+* @example
+* const result = await asyncIterLines('large-log.txt');
+* result.match({
+*   ok: async (iter) => {
+*     const errors = await iter
+*       .filter(line => line.includes('ERROR'))
+*       .take(100)
+*       .collect();
+*   },
+*   err: (e) => console.error(e)
+* });
+*/
+async function asyncIterLines(filepath) {
+	try {
+		await fs.promises.access(filepath, fs.constants.R_OK);
+	} catch (error) {
+		if (error instanceof Error) return require_async_iter.Err(`Failed to access file '${filepath}': ${error.message}`);
+		return require_async_iter.Err(`Failed to access file '${filepath}': ${String(error)}`);
+	}
+	return require_async_iter.Ok(require_async_iter.asyncIter((async function* () {
+		const fileStream = fs.createReadStream(filepath, { encoding: "utf-8" });
+		const rl = readline.createInterface({
+			input: fileStream,
+			crlfDelay: Infinity
+		});
+		try {
+			for await (const line of rl) yield line;
+		} finally {
+			rl.close();
+			fileStream.destroy();
+		}
+	})()));
+}
+
+//#endregion
+exports.asyncIterLines = asyncIterLines;
+exports.iterLinesSync = iterLinesSync;
+//# sourceMappingURL=node.cjs.map

package/dist/node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.cjs","names":["Ok","iter","Err","asyncIter"],"sources":["../src/node.ts"],"sourcesContent":["/**\n * Node.js-specific utilities for rustlike.\n *\n * This module contains functions that depend on Node.js built-in modules\n * (fs, readline) and should only be imported in Node.js environments.\n * Browser and edge runtime consumers should use the main 'rustlike' entry point.\n *\n * Import from 'rustlike/node' to access these functions.\n */\n\nimport * as fs from \"fs\";\nimport * as readline from \"readline\";\nimport { Result, Ok, Err } from \"./core\";\nimport { iter } from \"./iter\";\nimport { asyncIter } from \"./async-iter\";\nimport type { Iter } from \"./iter\";\nimport type { AsyncIter } from \"./async-iter\";\n\n// ============================================================================\n// File Reading (Sync)\n// ============================================================================\n\n/**\n * Create an Iter that lazily reads lines from a file.\n * Uses Node.js fs.readFileSync but yields lines lazily via generator.\n *\n * Note: This reads the entire file into memory but yields lines lazily.\n * For truly streaming line-by-line reading, use asyncIterLines.\n *\n * @param filepath - Path to the file to read\n * @returns Result with Iter<string> on success, error message on failure\n *\n * @example\n * const lines = iterLinesSync('data.txt');\n * lines.match({\n *   ok: (iter) => iter.skip(1).map(parseLine).collect(),\n *   err: (e) => console.error(e)\n * });\n */\nexport function iterLinesSync(filepath: string): Result<Iter<string>, string> {\n  try {\n    const content = fs.readFileSync(filepath, \"utf-8\");\n    const lines = content.split(\"\\n\");\n    // Remove trailing empty line if file ends with newline\n    if (lines.length > 0 && lines[lines.length - 1] === \"\") {\n      lines.pop();\n    }\n    return Ok(iter(lines));\n  } catch (error) {\n    if (error instanceof Error) {\n      return Err(`Failed to read file '${filepath}': ${error.message}`);\n    }\n    return Err(`Failed to read file '${filepath}': ${String(error)}`);\n  }\n}\n\n// ============================================================================\n// File Reading (Async)\n// ============================================================================\n\n/**\n * Create an AsyncIter that reads lines from a file using streaming.\n * Truly memory-efficient - reads lines on-demand without loading entire file.\n *\n * Uses Node.js readline with createReadStream for efficient streaming.\n *\n * @param filepath - Path to the file to read\n * @returns Promise of Result with AsyncIter<string> on success, error message on failure\n *\n * @example\n * const result = await asyncIterLines('large-log.txt');\n * result.match({\n *   ok: async (iter) => {\n *     const errors = await iter\n *       .filter(line => line.includes('ERROR'))\n *       .take(100)\n *       .collect();\n *   },\n *   err: (e) => console.error(e)\n * });\n */\nexport async function asyncIterLines(filepath: string): Promise<Result<AsyncIter<string>, string>> {\n  // Check if file exists first\n  try {\n    await fs.promises.access(filepath, fs.constants.R_OK);\n  } catch (error) {\n    if (error instanceof Error) {\n      return Err(`Failed to access file '${filepath}': ${error.message}`);\n    }\n    return Err(`Failed to access file '${filepath}': ${String(error)}`);\n  }\n\n  // Create the async iterator using readline\n  const asyncIterator = (async function* () {\n    const fileStream = fs.createReadStream(filepath, { encoding: \"utf-8\" });\n    const rl = readline.createInterface({\n      input: fileStream,\n      crlfDelay: Infinity, // Handle both \\n and \\r\\n\n    });\n\n    try {\n      for await (const line of rl) {\n        yield line;\n      }\n    } finally {\n      rl.close();\n      fileStream.destroy();\n    }\n  })();\n\n  return Ok(asyncIter(asyncIterator));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,cAAc,UAAgD;AAC5E,KAAI;EAEF,MAAM,QADU,GAAG,aAAa,UAAU,QAAQ,CAC5B,MAAM,KAAK;AAEjC,MAAI,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,OAAO,GAClD,OAAM,KAAK;AAEb,SAAOA,sBAAGC,wBAAK,MAAM,CAAC;UACf,OAAO;AACd,MAAI,iBAAiB,MACnB,QAAOC,uBAAI,wBAAwB,SAAS,KAAK,MAAM,UAAU;AAEnE,SAAOA,uBAAI,wBAAwB,SAAS,KAAK,OAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;AA6BrE,eAAsB,eAAe,UAA8D;AAEjG,KAAI;AACF,QAAM,GAAG,SAAS,OAAO,UAAU,GAAG,UAAU,KAAK;UAC9C,OAAO;AACd,MAAI,iBAAiB,MACnB,QAAOA,uBAAI,0BAA0B,SAAS,KAAK,MAAM,UAAU;AAErE,SAAOA,uBAAI,0BAA0B,SAAS,KAAK,OAAO,MAAM,GAAG;;AAqBrE,QAAOF,sBAAGG,8BAjBa,mBAAmB;EACxC,MAAM,aAAa,GAAG,iBAAiB,UAAU,EAAE,UAAU,SAAS,CAAC;EACvE,MAAM,KAAK,SAAS,gBAAgB;GAClC,OAAO;GACP,WAAW;GACZ,CAAC;AAEF,MAAI;AACF,cAAW,MAAM,QAAQ,GACvB,OAAM;YAEA;AACR,MAAG,OAAO;AACV,cAAW,SAAS;;KAEpB,CAE8B,CAAC"}

package/dist/node.d.cts

@@ -0,0 +1,46 @@
+import { g as Result, s as Iter, t as AsyncIter } from "./async-iter-D7Pj6knS.cjs";
+
+//#region src/node.d.ts
+/**
+ * Create an Iter that lazily reads lines from a file.
+ * Uses Node.js fs.readFileSync but yields lines lazily via generator.
+ *
+ * Note: This reads the entire file into memory but yields lines lazily.
+ * For truly streaming line-by-line reading, use asyncIterLines.
+ *
+ * @param filepath - Path to the file to read
+ * @returns Result with Iter<string> on success, error message on failure
+ *
+ * @example
+ * const lines = iterLinesSync('data.txt');
+ * lines.match({
+ *   ok: (iter) => iter.skip(1).map(parseLine).collect(),
+ *   err: (e) => console.error(e)
+ * });
+ */
+declare function iterLinesSync(filepath: string): Result<Iter<string>, string>;
+/**
+ * Create an AsyncIter that reads lines from a file using streaming.
+ * Truly memory-efficient - reads lines on-demand without loading entire file.
+ *
+ * Uses Node.js readline with createReadStream for efficient streaming.
+ *
+ * @param filepath - Path to the file to read
+ * @returns Promise of Result with AsyncIter<string> on success, error message on failure
+ *
+ * @example
+ * const result = await asyncIterLines('large-log.txt');
+ * result.match({
+ *   ok: async (iter) => {
+ *     const errors = await iter
+ *       .filter(line => line.includes('ERROR'))
+ *       .take(100)
+ *       .collect();
+ *   },
+ *   err: (e) => console.error(e)
+ * });
+ */
+declare function asyncIterLines(filepath: string): Promise<Result<AsyncIter<string>, string>>;
+//#endregion
+export { asyncIterLines, iterLinesSync };
+//# sourceMappingURL=node.d.cts.map

package/dist/node.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.cts","names":[],"sources":["../src/node.ts"],"mappings":";;;AAiFA;;;;;;;;;;;;;;;;;AAAA,iBA1CgB,aAAA,CAAc,QAAA,WAAmB,MAAA,CAAO,IAAA;;;;;;;;;;;;;;;;;;;;;;iBA0ClC,cAAA,CAAe,QAAA,WAAmB,OAAA,CAAQ,MAAA,CAAO,SAAA"}