Interface Either<E, T>

Either

interface Either<E, T> {
    @@type: string;
    ap<V>(eitherFn: monet.Either<E, ((val: T) => V)>): monet.Either<E, V>;
    apTo<V>(value: monet.Either<E, V>): T extends ((arg: V) => any)
        ? monet.Either<E, ReturnType<T<T>>>
        : never;
    bimap<Z, V>(leftFn: ((err: E) => Z), rightFn: ((val: T) => V)): monet.Either<Z, V>;
    bind<V>(fn: ((val: T) => monet.Either<E, V>)): monet.Either<E, V>;
    cata<Z>(leftFn: ((err: E) => Z), rightFn: ((val: T) => Z)): Z;
    catchMap<F>(fn: ((err: E) => monet.Either<F, T>)): monet.Either<F, T>;
    chain<V>(fn: ((val: T) => monet.Either<E, V>)): monet.Either<E, V>;
    equals(other: monet.Either<E, T>): boolean;
    fantasy-land/ap?<V>(afn: monet.Applicative<((val: T) => V)>): monet.Applicative<V>;
    fantasy-land/chain?<V>(fn: ((val: T) => monet.Chain<V>)): monet.Chain<V>;
    fantasy-land/equals?(other: monet.Either<E, T>): boolean;
    fantasy-land/map?<V>(fn: ((val: T) => V)): monet.Functor<V>;
    flatMap<V>(fn: ((val: T) => monet.Either<E, V>)): monet.Either<E, V>;
    fold<Z>(leftFn: ((err: E) => Z), rightFn: ((val: T) => Z)): Z;
    foldLeft<V>(initial: V): ((fn: ((acc: V, val: T) => V)) => V);
    foldRight<V>(initial: V): ((fn: ((val: T, acc: V) => V)) => V);
    forEach(fn: ((val: T) => void)): void;
    forEachLeft(fn: ((val: E) => void)): void;
    isLeft(): boolean;
    isRight(): boolean;
    join<V>(): monet.Either<E, V>;
    left(): E;
    leftMap<F>(fn: ((leftVal: E) => F)): monet.Either<F, T>;
    map<V>(fn: ((val: T) => V)): monet.Either<E, V>;
    right(): T;
    swap(): monet.Either<T, E>;
    takeLeft(m: monet.Either<E, T>): monet.Either<E, T>;
    takeRight(m: monet.Either<E, T>): monet.Either<E, T>;
    toMaybe(): monet.Maybe<T>;
    toPromise(): Promise<T>;
    toValidation(): monet.Validation<E, T>;
}

Type Parameters

  • E
  • T

Hierarchy-Diagram

UML class diagram of Either
Legend
icon for an interface in the UML class diagram interface
icon for a public method in the UML class diagram public method

Hierarchy (view full)

Properties

@@type

Methods

ap apTo bimap bind cata catchMap chain equals fantasy-land/ap? fantasy-land/chain? fantasy-land/equals? fantasy-land/map? flatMap fold foldLeft foldRight forEach forEachLeft isLeft isRight join left leftMap map right swap takeLeft takeRight toMaybe toPromise toValidation

Properties

@@type

@@type: string

Methods

ap

apTo

bimap

  • bimap<Z, V>(leftFn: ((err: E) => Z), rightFn: ((val: T) => V)): monet.Either<Z, V>

  • Type Parameters

    • Z
    • V

    Parameters

    • leftFn: ((err: E) => Z)
        • (err: E): Z

        • Parameters

          • err: E

          Returns Z

    • rightFn: ((val: T) => V)
        • (val: T): V

        • Parameters

          • val: T

          Returns V

    Returns monet.Either<Z, V>

bind

cata

  • cata<Z>(leftFn: ((err: E) => Z), rightFn: ((val: T) => Z)): Z

  • Type Parameters

    • Z

    Parameters

    • leftFn: ((err: E) => Z)
        • (err: E): Z

        • Parameters

          • err: E

          Returns Z

    • rightFn: ((val: T) => Z)
        • (val: T): Z

        • Parameters

          • val: T

          Returns Z

    Returns Z

catchMap

chain

equals

Optional fantasy-land/ap

Optional fantasy-land/chain

Optional fantasy-land/equals

Optional fantasy-land/map

flatMap

fold

  • fold<Z>(leftFn: ((err: E) => Z), rightFn: ((val: T) => Z)): Z

  • Type Parameters

    • Z

    Parameters

    • leftFn: ((err: E) => Z)
        • (err: E): Z

        • Parameters

          • err: E

          Returns Z

    • rightFn: ((val: T) => Z)
        • (val: T): Z

        • Parameters

          • val: T

          Returns Z

    Returns Z

foldLeft

  • foldLeft<V>(initial: V): ((fn: ((acc: V, val: T) => V)) => V)

  • Type Parameters

    • V

    Parameters

    • initial: V

    Returns ((fn: ((acc: V, val: T) => V)) => V)

      • (fn: ((acc: V, val: T) => V)): V

      • Parameters

        • fn: ((acc: V, val: T) => V)
            • (acc: V, val: T): V

            • Parameters

              • acc: V
              • val: T

              Returns V

        Returns V

foldRight

  • foldRight<V>(initial: V): ((fn: ((val: T, acc: V) => V)) => V)

  • Type Parameters

    • V

    Parameters

    • initial: V

    Returns ((fn: ((val: T, acc: V) => V)) => V)

      • (fn: ((val: T, acc: V) => V)): V

      • Parameters

        • fn: ((val: T, acc: V) => V)
            • (val: T, acc: V): V

            • Parameters

              • val: T
              • acc: V

              Returns V

        Returns V

forEach

  • forEach(fn: ((val: T) => void)): void

  • Parameters

    • fn: ((val: T) => void)
        • (val: T): void

        • Parameters

          • val: T

          Returns void

    Returns void

forEachLeft

  • forEachLeft(fn: ((val: E) => void)): void

  • Parameters

    • fn: ((val: E) => void)
        • (val: E): void

        • Parameters

          • val: E

          Returns void

    Returns void

isLeft

  • isLeft(): boolean

  • Returns boolean

isRight

  • isRight(): boolean

  • Returns boolean

join

left

  • left(): E

  • Returns E

leftMap

  • leftMap<F>(fn: ((leftVal: E) => F)): monet.Either<F, T>

  • Type Parameters

    • F

    Parameters

    • fn: ((leftVal: E) => F)
        • (leftVal: E): F

        • Parameters

          • leftVal: E

          Returns F

    Returns monet.Either<F, T>

map

  • map<V>(fn: ((val: T) => V)): monet.Either<E, V>

  • Type Parameters

    • V

    Parameters

    • fn: ((val: T) => V)
        • (val: T): V

        • Parameters

          • val: T

          Returns V

    Returns monet.Either<E, V>

right

  • right(): T

  • Returns T

swap

takeLeft

takeRight

toMaybe

toPromise

  • toPromise(): Promise<T>

  • Returns Promise<T>

toValidation

Settings

Member Visibility

Theme

On This Page

@@typeapapTobimapbindcatacatchMapchainequalsfantasy-land/apfantasy-land/chainfantasy-land/equalsfantasy-land/mapflatMapfoldfoldLeftfoldRightforEachforEachLeftisLeftisRightjoinleftleftMapmaprightswaptakeLefttakeRighttoMaybetoPromisetoValidation