Type Alias Either<L, R>

Either: {
    _tag: "Left" | "Right";
    "[iterator]": () => Iterator<R>;
    bimap: <L2 extends Type, R2 extends Type>(
        fl: (value: L) => L2,
        fr: (value: R) => R2,
    ) => Either<L2, R2>;
    flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
    flatMapAsync: <U extends Type>(
        f: (value: R) => Promise<Either<L, U>>,
    ) => Promise<Either<L, U>>;
    fold: <T extends Type>(
        onLeft: (value: L) => T,
        onRight: (value: R) => T,
    ) => T;
    getOrElse: (defaultValue: R) => R;
    getOrThrow: () => R;
    isLeft: () => boolean;
    isRight: () => boolean;
    lazyMap: <U extends Type>(
        f: (value: R) => U,
    ) => Generator<Either<L, U>, void, unknown>;
    map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
    mapAsync: <U extends Type>(
        f: (value: R) => Promise<U>,
    ) => Promise<Either<L, U>>;
    mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
    merge: <L1 extends Type, R1 extends Type>(
        other: Either<L1, R1>,
    ) => Either<L | L1, [R, R1]>;
    swap: () => Either<R, L>;
    tap: (f: (value: R) => void) => Either<L, R>;
    tapLeft: (f: (value: L) => void) => Either<L, R>;
    toList: () => List<R>;
    toOption: () => Option<R>;
    toString: () => string;
    traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
    value: L | R;
    yield: () => Generator<R, void, unknown>;
} & Typeable<"Left" | "Right"> & Valuable<"Left" | "Right", L | R> & PromiseLike<
    R,
> & AsyncFunctor<R>