58 lines
3.2 KiB
TypeScript
58 lines
3.2 KiB
TypeScript
declare const errorSym: unique symbol;
|
|
export type Result<A> = A | Failure;
|
|
export interface Failure {
|
|
readonly [errorSym]: string;
|
|
}
|
|
export interface Fail {
|
|
(error: string): Failure;
|
|
in(prefix: string): Fail;
|
|
locate<A>(x: Result<A>): Result<A>;
|
|
}
|
|
export interface failure extends Fail {
|
|
}
|
|
export declare function failure(error: string): Failure;
|
|
export declare namespace failure {
|
|
var _a: (prefix: string) => Fail;
|
|
export var locate: <A>(x: Result<A>) => Result<A>;
|
|
export { _a as in };
|
|
}
|
|
export declare function isFailure<A>(x: Result<A>): x is Failure;
|
|
export declare function isSuccess<A>(x: Result<A>): x is A;
|
|
export declare function unpack<A>(x: Result<A>): A;
|
|
export declare function unpackOr<A, B>(x: Result<A>, def: B): B extends A ? A : A | B;
|
|
export declare function errorMessage(x: Failure): string;
|
|
export declare function errorFrom(x: Failure): Error;
|
|
export declare function assertSuccess<A>(x: Result<A>): asserts x is A;
|
|
export declare function assertSuccess(x: Failure): never;
|
|
export declare function tryCatch<A>(block: () => A): Result<A>;
|
|
export declare function tryCatch<A>(failFn: Fail, block: () => A): Result<A>;
|
|
export declare function using<A, B>(value: Result<A>, block: (x: A) => Result<B>): Result<B>;
|
|
/**
|
|
* Like 'using', but can take any number of functions
|
|
*/
|
|
export declare function chain<A, B>(value: Result<A>, b0: (x: A) => Result<B>): Result<B>;
|
|
export declare function chain<A, B, C>(value: Result<A>, b0: (x: A) => Result<B>, b1: (x: B) => Result<C>): Result<C>;
|
|
export declare function chain<A, B, C, D>(value: Result<A>, b0: (x: A) => Result<B>, b1: (x: B) => Result<C>, b2: (x: C) => Result<D>): Result<D>;
|
|
export declare function chain<A, B, C, D, E>(value: Result<A>, b0: (x: A) => Result<B>, b1: (x: B) => Result<C>, b2: (x: C) => Result<D>, b3: (x: D) => Result<E>): Result<E>;
|
|
export declare function chain<A, B, C, D, E, F>(value: Result<A>, b0: (x: A) => Result<B>, b1: (x: B) => Result<C>, b2: (x: C) => Result<D>, b3: (x: D) => Result<E>, b4: (x: E) => Result<F>): Result<F>;
|
|
export declare function chain<A, B, C, D, E, F, G>(value: Result<A>, b0: (x: A) => Result<B>, b1: (x: B) => Result<C>, b2: (x: C) => Result<D>, b3: (x: D) => Result<E>, b4: (x: E) => Result<F>, b5: (x: F) => Result<G>): Result<G>;
|
|
/**
|
|
* Make a function that will prepend a prefix to error messages
|
|
*
|
|
* This is one way to be specific about the location where errors originate, by prefixing
|
|
* errors as the call stack unwinds.
|
|
*
|
|
* A different method is to pass in a modified failure function using `failure.in(...)`,
|
|
* to build the error message as the call stack deepens.
|
|
*/
|
|
export declare function locateFailure(prefix: string): <A>(x: Result<A>) => Result<A>;
|
|
export type Failures = Array<Failure>;
|
|
export declare function liftResult<A>(xs: Record<string, Result<A>>): Result<Record<string, A>>;
|
|
export declare function liftResult<A>(xs: Array<Result<A>>): Result<Array<A>>;
|
|
/**
|
|
* Lift a value that can be 'undefined' to a result, or a function that can return undefined.
|
|
*/
|
|
export declare function liftUndefined<A>(v: A | undefined): Result<NonNullable<A>>;
|
|
export declare function liftUndefined<A, F extends (...args: any[]) => A>(v: F): (x: Parameters<F>) => Result<NonNullable<A>>;
|
|
export {};
|