Type Alias FPromise<T, E>

FPromise: PromiseLike<T> & {
    _tag: "FPromise";
    filterError: <E2 extends E>(
        predicate: (error: E) => boolean,
        handler: (error: E) => FPromise<T, E2>,
    ) => FPromise<T, E>;
    flatMap: <U extends Type>(
        f: (value: T) => FPromise<U, E> | PromiseLike<U>,
    ) => FPromise<U, E>;
    flatMapAsync: <U extends Type>(
        f: (value: T) => PromiseLike<U>,
    ) => Promise<U>;
    fold: <R extends Type>(
        onError: (error: E) => R,
        onSuccess: (value: T) => R,
    ) => FPromise<R, never>;
    logError: (
        logger: (error: E, context: ErrorContext) => void,
    ) => FPromise<T, E>;
    map: <U extends Type>(f: (value: T) => U) => FPromise<U, E>;
    mapError: <E2>(
        f: (error: E, context: ErrorContext) => E2,
    ) => FPromise<T, E2>;
    recover: (fallback: T) => FPromise<T, never>;
    recoverWith: (f: (error: E) => T) => FPromise<T, never>;
    recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>) => FPromise<T, E2>;
    tap: (f: (value: T) => void) => FPromise<T, E>;
    tapError: (f: (error: E) => void) => FPromise<T, E>;
    toEither: () => Promise<T>;
    toPromise: () => Promise<T>;
}