/**
 * Naive "either or" type implementation.
 *
 * This differs from other implementations mostly in how relaxed the type inferrence is.
 *
 * Again, this could easily be replaced with something from e.g. fp-ts, but the goal is
 * to have a single "prelude/stdlib" here.
 *
 *
 * @module
 * @deprecated use effect instead
 */
export type Either<Left, Right> = {
    __tag: "left";
    left: Left;
} | {
    __tag: "right";
    right: Right;
};
export type Left<E extends Either<any, any>> = E extends Either<infer Left, any> ? Left : never;
export type Right<E extends Either<any, any>> = E extends Either<any, infer Right> ? Right : never;
export declare const left: <const Left>(left: Left) => Either<Left, never>;
export declare const right: <const Right>(right: Right) => Either<never, Right>;
export declare const map: <R1, R2, L>(fn: (value: R1) => R2) => (either: Either<L, R1>) => Either<L, R2>;
export declare const flatMap: <L1, R1, E extends Either<any, any>>(fn: (value: R1) => E) => (either: Either<L1, R1>) => Either<L1 | Left<NoInfer<E>>, Right<NoInfer<E>>>;
export declare const match: <T, Left, Right>(onLeft: (left: Left) => T, onRight: (right: Right) => T) => (either: Either<Left, Right>) => T;
export declare const getOrElse: <L, R, F>(fallback: (left: L) => F) => (either: Either<L, R | F>) => R | F;
export declare const alt: <Left, Right>(second: Either<Left, Right>) => (first: Either<Left, Right>) => Either<Left, Right>;