@daisugi/anzen/dist/types/anzen.d.ts

Anzen helps write safe code without exceptions, taking roots from Rust's Result and Haskell's Either.

export type AnzenResultSuccess<T> = ResultSuccess<T>;
export type AnzenResultFailure<E> = ResultFailure<E>;
export type AnzenAnyResult<E, T> = AnzenResultFailure<E> | AnzenResultSuccess<T>;
type ExtractFailure<T extends readonly unknown[]> = Awaited<T[number]> extends infer R ? R extends AnzenResultFailure<infer U> ? U : never : never;
type ExtractSuccess<T extends readonly unknown[]> = {
    [K in keyof T]: Awaited<T[K]> extends infer R ? R extends AnzenResultSuccess<infer U> ? U : never : never;
};
export type AnzenResultFn<E, T> = (...args: any[]) => AnzenAnyResult<E, T> | Promise<AnzenAnyResult<E, T>>;
export declare class ResultSuccess<T> {
    #private;
    readonly isSuccess = true;
    readonly isFailure = false;
    constructor(value: T);
    getValue(): T;
    getOrElse<V>(_: V): T;
    getError(): never;
    chain<V extends AnzenAnyResult<any, any>>(fn: (val: T) => V): V;
    elseChain(_: (val: T) => any): this;
    map<V>(fn: (val: T) => V): AnzenResultSuccess<V>;
    elseMap(_: (val: T) => any): this;
    unwrap(): [this, T];
    unsafeUnwrap(): T;
    toJSON(): string;
}
export declare class ResultFailure<E> {
    #private;
    readonly isSuccess = false;
    readonly isFailure = true;
    constructor(err: E);
    getValue(): never;
    getOrElse<T>(defaultVal: T): T;
    getError(): E;
    chain(_: (err: E) => any): this;
    elseChain<V extends AnzenAnyResult<any, any>>(fn: (err: E) => V): V;
    map(_: (err: E) => any): this;
    elseMap<V>(fn: (err: E) => V): AnzenResultSuccess<V>;
    unwrap<V = undefined>(defaultVal?: V): [this, V];
    unsafeUnwrap(): E;
    toJSON(): string;
}
export declare class Result {
    static success: <T>(val: T) => AnzenResultSuccess<T>;
    static failure: <E>(err: E) => AnzenResultFailure<E>;
    static promiseAll<const T extends (AnzenAnyResult<any, any> | Promise<AnzenAnyResult<any, any>>)[]>(whenRes: T): Promise<AnzenResultSuccess<ExtractSuccess<T>> | AnzenResultFailure<ExtractFailure<T>>>;
    static unwrapPromiseAll<const T extends (AnzenAnyResult<any, any> | Promise<AnzenAnyResult<any, any>>)[], const D extends unknown[] = unknown[]>(args: [D, ...T]): Promise<[AnzenResultSuccess<ExtractSuccess<T>>, ...ExtractSuccess<T>] | [AnzenResultFailure<ExtractFailure<T>>, ...ExtractSuccess<T>]>;
    static unwrap<T, E, D = undefined>(defaultVal?: D): (res: AnzenAnyResult<E, T>) => [AnzenResultFailure<E>, D] | [AnzenResultSuccess<T>, T];
    static fromJSON<T = any, E = any>(json: string): AnzenAnyResult<E, T>;
    static fromSyncThrowable<T, E = unknown>(fn: () => T, parseErr?: (err: unknown) => E): AnzenAnyResult<E, T>;
    static fromThrowable<T, E = unknown>(fn: () => Promise<T>, parseErr?: (err: unknown) => E): Promise<AnzenAnyResult<E, T>>;
}
export {};
//# sourceMappingURL=anzen.d.ts.map