@pithos/core 2.0.0

package/dist/zygos/result/result.d.ts

@@ -0,0 +1,537 @@
+/**
+ * Micro implementation of Neverthrow's Result type.
+ *
+ * This is a lightweight alternative to Neverthrow 8.2.0 that is:
+ * - 8x smaller (~0.79KB vs ~6.62KB from Neverthrow 8.2.0)
+ * - 100% API compatible with Neverthrow 8.2.0 - can be seamlessly replaced without code changes
+ * - Zero `any` types for better type safety
+ *
+ * This module provides a lightweight implementation of the Result monad pattern,
+ * offering a type-safe way to handle operations that can either succeed or fail.
+ * All functions are tree-shakable and framework-agnostic.
+ *
+ * Features:
+ * - Zero `any` types for maximum type safety
+ * - Full TypeScript 5 support with modern syntax
+ * - Comprehensive error handling and chaining
+ *
+ * @example
+ * ```typescript
+ * import { ok, err, Result } from './result';
+ *
+ * // Success case
+ * const success: Result<number, string> = ok(42);
+ * if (success.isOk()) {
+ *   console.log(success.value); // 42
+ * }
+ *
+ * // Error case
+ * const failure: Result<number, string> = err("Invalid input");
+ * if (failure.isErr()) {
+ *   console.log(failure.error); // "Invalid input"
+ * }
+ * ```
+ *
+ * @since 1.1.0
+ */
+/**
+ * Union type representing either a successful result (Ok) or an error result (Err).
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ * @since 2.0.0
+ */
+export type Result<T, E> = Ok<T, E> | Err<T, E>;
+/**
+ * Utility type to infer the success type from a Result type.
+ * Uses `unknown` instead of `any` for better type safety.
+ *
+ * @template R - The Result type to extract the success type from
+ */
+type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
+/**
+ * Utility type to infer the error type from a Result type.
+ * Uses `unknown` instead of `any` for better type safety.
+ *
+ * @template R - The Result type to extract the error type from
+ */
+type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
+/**
+ * Interface defining the contract for Result objects.
+ * Both Ok and Err classes implement this interface.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ */
+interface IResult<T, E> {
+    /**
+     * Type guard that returns true if this is a successful result.
+     *
+     * @returns `true` if this is an Ok result, `false` otherwise
+     */
+    isOk(): this is Ok<T, E>;
+    /**
+     * Type guard that returns true if this is an error result.
+     *
+     * @returns `true` if this is an Err result, `false` otherwise
+     */
+    isErr(): this is Err<T, E>;
+    /**
+     * Transforms the success value using the provided function.
+     * If this is an error result, the error is preserved unchanged.
+     *
+     * @template A - The type of the transformed value
+     * @param f - Function to transform the success value
+     * @returns A new Result with the transformed value or the original error
+     *
+     * @example
+     * ```typescript
+     * const result = ok(5);
+     * const doubled = result.map(x => x * 2); // Ok(10)
+     *
+     * const error = err("failed");
+     * const mapped = error.map(x => x * 2); // Err("failed")
+     * ```
+     */
+    map<A>(f: (t: T) => A): Result<A, E>;
+    /**
+     * Transforms the error value using the provided function.
+     * If this is a success result, the value is preserved unchanged.
+     *
+     * @template U - The type of the transformed error
+     * @param f - Function to transform the error value
+     * @returns A new Result with the original value or the transformed error
+     *
+     * @example
+     * ```typescript
+     * const error = err("network error");
+     * const enhanced = error.mapErr(e => `Error: ${e}`); // Err("Error: network error")
+     *
+     * const success = ok(42);
+     * const mapped = success.mapErr(e => "Unknown error"); // Ok(42)
+     * ```
+     */
+    mapErr<U>(f: (e: E) => U): Result<T, U>;
+    /**
+     * Chains operations by applying the provided function to the success value.
+     * If this is an error result, the error is propagated unchanged.
+     *
+     * @template R - The type of the Result returned by the function
+     * @param f - Function that takes the success value and returns a new Result
+     * @returns A new Result from the function or the original error
+     *
+     * @example
+     * ```typescript
+     * const result = ok(5);
+     * const chained = result.andThen(x =>
+     *   x > 0 ? ok(x * 2) : err("negative")
+     * ); // Ok(10)
+     *
+     * const error = err("failed");
+     * const propagated = error.andThen(x => ok(x * 2)); // Err("failed")
+     * ```
+     */
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    /**
+     * Chains operations with explicit type parameters.
+     *
+     * @template U - The type of the success value in the returned Result
+     * @template F - The type of the error value in the returned Result
+     * @param f - Function that takes the success value and returns a new Result
+     * @returns A new Result with combined error types
+     */
+    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+    /**
+     * Returns the success value if this is an Ok result, otherwise returns the default value.
+     *
+     * @template A - The type of the default value
+     * @param v - Default value to return if this is an error result
+     * @returns The success value or the default value
+     *
+     * @example
+     * ```typescript
+     * const success = ok(42);
+     * success.unwrapOr(0); // 42
+     *
+     * const error = err("failed");
+     * error.unwrapOr(0); // 0
+     * ```
+     */
+    unwrapOr<A>(v: A): T | A;
+    /**
+     * Pattern matching function that executes different code paths based on the result state.
+     *
+     * @template A - The return type for the success case
+     * @template B - The return type for the error case (defaults to A)
+     * @param ok - Function to execute if this is a success result
+     * @param err - Function to execute if this is an error result
+     * @returns The result of executing the appropriate function
+     *
+     * @example
+     * ```typescript
+     * const result = ok(42);
+     * const message = result.match(
+     *   value => `Success: ${value}`,
+     *   error => `Error: ${error}`
+     * ); // "Success: 42"
+     * ```
+     */
+    match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
+}
+/**
+ * Represents a successful result containing a value.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value (unused in Ok)
+ * @since 2.0.0
+ */
+export declare class Ok<T, E> implements IResult<T, E> {
+    readonly value: T;
+    /**
+     * Creates a new Ok result.
+     *
+     * @param value - The success value to wrap
+     */
+    constructor(value: T);
+    /**
+     * Always returns true for Ok instances.
+     *
+     * @returns `true`
+     */
+    isOk(): this is Ok<T, E>;
+    /**
+     * Always returns false for Ok instances.
+     * Optimized to return the constant value directly.
+     *
+     * @returns `false`
+     */
+    isErr(): this is Err<T, E>;
+    /**
+     * Transforms the success value using the provided function.
+     *
+     * @template A - The type of the transformed value
+     * @param f - Function to transform the success value
+     * @returns A new Ok result with the transformed value
+     */
+    map<A>(f: (t: T) => A): Result<A, E>;
+    /**
+     * No-op for Ok instances - the error transformation function is ignored.
+     *
+     * @template U - The type of the transformed error (unused)
+     * @param _f - Error transformation function (ignored)
+     * @returns A new Ok result with the original value
+     */
+    mapErr<U>(_f: (e: E) => U): Result<T, U>;
+    /**
+     * Chains operations by applying the provided function to the success value.
+     *
+     * @template R - The type of the Result returned by the function
+     * @param f - Function that takes the success value and returns a new Result
+     * @returns The Result returned by the function
+     */
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    /**
+     * Chains operations with explicit type parameters.
+     *
+     * @template U - The type of the success value in the returned Result
+     * @template F - The type of the error value in the returned Result
+     * @param f - Function that takes the success value and returns a new Result
+     * @returns The Result returned by the function
+     */
+    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+    /**
+     * Always returns the success value for Ok instances.
+     *
+     * @template A - The type of the default value (unused)
+     * @param _v - Default value (ignored)
+     * @returns The success value
+     */
+    unwrapOr<A>(_v: A): T | A;
+    /**
+     * Executes the success function with the success value.
+     *
+     * @template A - The return type for the success case
+     * @template B - The return type for the error case (unused)
+     * @param ok - Function to execute with the success value
+     * @param _err - Error function (ignored)
+     * @returns The result of executing the success function
+     */
+    match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
+}
+/**
+ * Represents an error result containing an error value.
+ *
+ * @template T - The type of the success value (unused in Err)
+ * @template E - The type of the error value
+ * @since 2.0.0
+ */
+export declare class Err<T, E> implements IResult<T, E> {
+    readonly error: E;
+    /**
+     * Creates a new Err result.
+     *
+     * @param error - The error value to wrap
+     */
+    constructor(error: E);
+    /**
+     * Always returns false for Err instances.
+     *
+     * @returns `false`
+     */
+    isOk(): this is Ok<T, E>;
+    /**
+     * Always returns true for Err instances.
+     * Optimized to return the constant value directly.
+     *
+     * @returns `true`
+     */
+    isErr(): this is Err<T, E>;
+    /**
+     * No-op for Err instances - the value transformation function is ignored.
+     *
+     * @template A - The type of the transformed value (unused)
+     * @param _f - Transformation function (ignored)
+     * @returns A new Err result with the original error
+     */
+    map<A>(_f: (t: T) => A): Result<A, E>;
+    /**
+     * Transforms the error value using the provided function.
+     *
+     * @template U - The type of the transformed error
+     * @param f - Function to transform the error value
+     * @returns A new Err result with the transformed error
+     */
+    mapErr<U>(f: (e: E) => U): Result<T, U>;
+    /**
+     * No-op for Err instances - the chaining function is ignored.
+     *
+     * @template R - The type of the Result returned by the function (unused)
+     * @param _f - Chaining function (ignored)
+     * @returns A new Err result with the original error
+     */
+    andThen<R extends Result<unknown, unknown>>(_f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    /**
+     * No-op for Err instances with explicit type parameters.
+     *
+     * @template U - The type of the success value in the returned Result (unused)
+     * @template F - The type of the error value in the returned Result (unused)
+     * @param _f - Chaining function (ignored)
+     * @returns A new Err result with the original error
+     */
+    andThen<U, F>(_f: (t: T) => Result<U, F>): Result<U, E | F>;
+    /**
+     * Always returns the default value for Err instances.
+     *
+     * @template A - The type of the default value
+     * @param v - Default value to return
+     * @returns The default value
+     */
+    unwrapOr<A>(v: A): T | A;
+    /**
+     * Executes the error function with the error value.
+     *
+     * @template A - The return type for the success case (unused)
+     * @template B - The return type for the error case
+     * @param _ok - Success function (ignored)
+     * @param err - Function to execute with the error value
+     * @returns The result of executing the error function
+     */
+    match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
+}
+/**
+ * Creates a new successful result.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value (defaults to never)
+ * @param value - The value to wrap in a successful result
+ * @returns A new Ok result containing the value
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const result = ok(42);
+ * result.isOk(); // true
+ * result.value; // 42
+ * ```
+ */
+export declare function ok<T, E = never>(value: T): Ok<T, E>;
+/**
+ * Creates a new error result.
+ *
+ * @template T - The type of the success value (defaults to never)
+ * @template E - The type of the error value (defaults to unknown)
+ * @param error - The error to wrap in an error result
+ * @returns A new Err result containing the error
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const result = err("Something went wrong");
+ * result.isErr(); // true
+ * result.error; // "Something went wrong"
+ * ```
+ */
+export declare function err<T = never, E = unknown>(error: E): Err<T, E>;
+/**
+ * Executes a generator function that can yield error results and return a final result.
+ * This provides a way to handle errors in a more functional style.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ * @param body - Generator function that yields errors and returns a final result, or a function that returns a Result directly
+ * @returns The final result from the generator or function
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const result = safeTry(function* () {
+ *   const user = yield validateUser(input);
+ *   const profile = yield fetchProfile(user.id);
+ *   return ok({ user, profile });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const result = safeTry(() => ok(42));
+ * ```
+ */
+export declare function safeTry<T, E>(body: (() => Generator<Err<never, E>, Result<T, E>>) | (() => Result<T, E>)): Result<T, E>;
+/**
+ * Namespace containing utility functions for working with Result types.
+ * TypeScript allows type and namespace with the same name (declaration merging).
+ */
+export declare namespace Result {
+    /**
+     * Wraps a function with try-catch error handling, creating a new function
+     * that returns a Result instead of throwing exceptions.
+     *
+     * Uses `unknown` types for maximum type safety and modern TypeScript syntax.
+     *
+     * @template Fn - The type of the function to wrap
+     * @template E - The type of the error value
+     * @param fn - Function to wrap with error handling
+     * @param errorFn - Optional function to transform thrown errors
+     * @returns A new function that returns a Result instead of throwing
+     *
+     * @example
+     * ```typescript
+     * const safeParse = Result.fromThrowable(
+     *   JSON.parse,
+     *   (error) => `Parse error: ${error}`
+     * );
+     *
+     * const result = safeParse('{"valid": "json"}');
+     * // result is Ok({valid: "json"})
+     *
+     * const error = safeParse('invalid json');
+     * // error is Err("Parse error: SyntaxError: ...")
+     * ```
+     */
+    function fromThrowable<Fn extends (...args: readonly unknown[]) => unknown, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+    /**
+     * Combines multiple Results into a single Result containing an array of values.
+     * Returns the first error encountered, or all values if all Results are Ok.
+     * This is useful for collecting multiple operations that can fail.
+     *
+     * Uses `unknown` types for maximum type safety and compatibility.
+     *
+     * @template T - The type of the Results to combine
+     * @param resultList - Array of Results to combine
+     * @returns A Result containing an array of all values, or the first error
+     *
+     * @example
+     * ```typescript
+     * const results = [
+     *   ok(1),
+     *   ok(2),
+     *   ok(3)
+     * ];
+     *
+     * const combined = Result.combine(results);
+     * // combined is Ok([1, 2, 3])
+     *
+     * @example
+     * ```typescript
+     * const withError = [
+     *   ok(1),
+     *   err("second failed"),
+     *   ok(3)
+     * ];
+     *
+     * const failed = Result.combine(withError);
+     * // failed is Err("second failed")
+     * ```
+     */
+    function combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): Result<readonly unknown[], unknown>;
+}
+/**
+ * Wraps an async function with try-catch error handling, returning a Promise
+ * that resolves to a Result instead of rejecting.
+ *
+ * Uses `unknown` for error types to maintain maximum type safety and flexibility.
+ *
+ * @template T - The type of the value returned by the async function
+ * @param fn - Async function to wrap with error handling
+ * @returns A Promise that resolves to a Result
+ * @since 1.1.0
+ *
+ * @example
+ * ```typescript
+ * const fetchUser = async (id: string) => {
+ *   const response = await fetch(`/api/users/${id}`);
+ *   return response.json();
+ * };
+ *
+ * const result = await safeAsyncTry(() => fetchUser("123"));
+ * if (result.isOk()) {
+ *   console.log(result.value); // User data
+ * } else {
+ *   console.log(result.error); // Error details
+ * }
+ * ```
+ */
+export declare function safeAsyncTry<T>(fn: () => Promise<T>): Promise<Result<T, unknown>>;
+/**
+ * Converts an Option to a Result.
+ *
+ * @template E - The error type
+ * @param onNone - Function to create error when Option is None
+ * @returns A function that converts an Option to a Result
+ * @since 2.0.0
+ */
+export declare const fromOption: <E>(onNone: () => E) => <A>(fa: {
+    _tag: "Some" | "None";
+    value?: A;
+}) => Result<A, E>;
+/**
+ * Converts an Either to a Result.
+ *
+ * @template E - The error type
+ * @template A - The success type
+ * @param fa - The Either to convert
+ * @returns A Result
+ * @since 2.0.0
+ */
+export declare const fromEither: <E, A>(fa: {
+    _tag: "Left" | "Right";
+    left?: E;
+    right?: A;
+}) => Result<A, E>;
+/**
+ * Converts a Result to an Either.
+ *
+ * @template A - The success type
+ * @template E - The error type
+ * @param fa - The Result to convert
+ * @returns An Either
+ * @since 2.0.0
+ */
+export declare const toEither: <A, E>(fa: Result<A, E>) => {
+    _tag: "Left" | "Right";
+    left?: E;
+    right?: A;
+};
+export * from "./result-async";
+export { okAsync, errAsync, ResultAsync, fromPromise, fromSafePromise, fromAsyncThrowable, } from "./result-async";
+//# sourceMappingURL=result.d.ts.map

package/dist/zygos/result/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/zygos/result/result.ts"],"names":[],"mappings":"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"}