Interface Either<L, R>

interface Either<L, R> {
    alt(other: functional.Either<L, R>): functional.Either<L, R>;
    altLazy(other: () => functional.Either<L, R>): functional.Either<L, R>;
    ap<L2, R2>(
        other: functional.Either<L2, (value: R) => R2>,
    ): functional.Either<L | L2, R2>;
    bimap<L2, R2>(
        f: (value: L) => L2,
        g: (value: R) => R2,
    ): functional.Either<L2, R2>;
    caseOf<T>(patterns: functional.EitherPatterns<L, R, T>): T;
    chain<L2, R2>(
        f: (value: R) => functional.Either<L2, R2>,
    ): functional.Either<L | L2, R2>;
    chainLeft<L2, R2>(
        f: (value: L) => functional.Either<L2, R2>,
    ): functional.Either<L2, R | R2>;
    equals(other: functional.Either<L, R>): boolean;
    extend<R2>(
        f: (value: functional.Either<L, R>) => R2,
    ): functional.Either<L, R2>;
    extract(): L | R;
    "fantasy-land/alt"(other: functional.Either<L, R>): functional.Either<L, R>;
    "fantasy-land/ap"<R2>(
        other: functional.Either<L, (value: R) => R2>,
    ): functional.Either<L, R2>;
    "fantasy-land/bimap"<L2, R2>(
        f: (value: L) => L2,
        g: (value: R) => R2,
    ): functional.Either<L2, R2>;
    "fantasy-land/chain"<L2, R2>(
        f: (value: R) => functional.Either<L2, R2>,
    ): functional.Either<L | L2, R2>;
    "fantasy-land/equals"(other: functional.Either<L, R>): boolean;
    "fantasy-land/extend"<R2>(
        f: (value: functional.Either<L, R>) => R2,
    ): functional.Either<L, R2>;
    "fantasy-land/map"<R2>(f: (value: R) => R2): functional.Either<L, R2>;
    "fantasy-land/reduce"<T>(
        reducer: (accumulator: T, value: R) => T,
        initialValue: T,
    ): T;
    ifLeft(effect: (value: L) => any): this;
    ifRight(effect: (value: R) => any): this;
    inspect(): string;
    isLeft(): this is functional.Either<L, never>;
    isRight(): this is functional.Either<never, R>;
    join<L2, R2>(
        this: functional.Either<L, functional.Either<L2, R2>>,
    ): functional.Either<L | L2, R2>;
    leftOrDefault(defaultValue: L): L;
    leftOrDefaultLazy(getDefaultValue: () => L): L;
    leftToMaybe(): functional.Maybe<L>;
    map<R2>(f: (value: R) => R2): functional.Either<L, R2>;
    mapLeft<L2>(f: (value: L) => L2): functional.Either<L2, R>;
    orDefault(defaultValue: R): R;
    orDefaultLazy(getDefaultValue: () => R): R;
    reduce<T>(reducer: (accumulator: T, value: R) => T, initialValue: T): T;
    swap(): functional.Either<R, L>;
    toJSON(): L | R;
    toMaybe(): functional.Maybe<R>;
    toString(): string;
    unsafeCoerce(): R;
}

Type Parameters

  • L
  • R

Methods

alt altLazy ap bimap caseOf chain chainLeft equals extend extract fantasy-land/alt fantasy-land/ap fantasy-land/bimap fantasy-land/chain fantasy-land/equals fantasy-land/extend fantasy-land/map fantasy-land/reduce ifLeft ifRight inspect isLeft isRight join leftOrDefault leftOrDefaultLazy leftToMaybe map mapLeft orDefault orDefaultLazy reduce swap toJSON toMaybe toString unsafeCoerce

Methods

alt

altLazy

ap

bimap

  • bimap<L2, R2>(
        f: (value: L) => L2,
        g: (value: R) => R2,
    ): functional.Either<L2, R2>

  • Given two functions, maps the value inside this using the first if this is Left or using the second one if this is Right. If both functions return the same type consider using Either#either instead

    Type Parameters

    • L2
    • R2

    Parameters

    • f: (value: L) => L2
    • g: (value: R) => R2

    Returns functional.Either<L2, R2>

caseOf

chain

chainLeft

equals

  • equals(other: functional.Either<L, R>): boolean

  • Compares this to another Either, returns false if the constructors or the values inside are different, e.g. Right(5).equals(Left(5)) is false

    Parameters

    Returns boolean

extend

extract

  • extract(): L | R

  • Extracts the value out of this

    Returns L | R

fantasy-land/alt

fantasy-land/ap

fantasy-land/bimap

fantasy-land/chain

fantasy-land/equals

fantasy-land/extend

fantasy-land/map

fantasy-land/reduce

  • "fantasy-land/reduce"<T>(
        reducer: (accumulator: T, value: R) => T,
        initialValue: T,
    ): T

  • Type Parameters

    • T

    Parameters

    • reducer: (accumulator: T, value: R) => T
    • initialValue: T

    Returns T

ifLeft

  • ifLeft(effect: (value: L) => any): this

  • Runs an effect if this is Left, returns this to make chaining other methods possible

    Parameters

    • effect: (value: L) => any

    Returns this

ifRight

  • ifRight(effect: (value: R) => any): this

  • Runs an effect if this is Right, returns this to make chaining other methods possible

    Parameters

    • effect: (value: R) => any

    Returns this

inspect

  • inspect(): string

  • Returns string

isLeft

  • isLeft(): this is functional.Either<L, never>

  • Returns true if this is Left, otherwise it returns false

    Returns this is functional.Either<L, never>

isRight

  • isRight(): this is functional.Either<never, R>

  • Returns true if this is Right, otherwise it returns false

    Returns this is functional.Either<never, R>

join

leftOrDefault

  • leftOrDefault(defaultValue: L): L

  • Returns the value inside this if it's Left or a default value if this is Right

    Parameters

    • defaultValue: L

    Returns L

leftOrDefaultLazy

  • leftOrDefaultLazy(getDefaultValue: () => L): L

  • Lazy version of leftOrDefault. Takes a function that returns the default value, that function will be called only if this is Right

    Parameters

    • getDefaultValue: () => L

    Returns L

leftToMaybe

  • leftToMaybe(): functional.Maybe<L>

  • Constructs a Just with the value of this if it's Left or a Nothing if this is Right

    Returns functional.Maybe<L>

map

  • map<R2>(f: (value: R) => R2): functional.Either<L, R2>

  • Maps the Right value of this, acts like an identity if this is Left

    Type Parameters

    • R2

    Parameters

    • f: (value: R) => R2

    Returns functional.Either<L, R2>

mapLeft

  • mapLeft<L2>(f: (value: L) => L2): functional.Either<L2, R>

  • Maps the Left value of this, acts like an identity if this is Right

    Type Parameters

    • L2

    Parameters

    • f: (value: L) => L2

    Returns functional.Either<L2, R>

orDefault

  • orDefault(defaultValue: R): R

  • Returns the value inside this if it's Right or a default value if this is Left

    Parameters

    • defaultValue: R

    Returns R

orDefaultLazy

  • orDefaultLazy(getDefaultValue: () => R): R

  • Lazy version of orDefault. Takes a function that returns the default value, that function will be called only if this is Left

    Parameters

    • getDefaultValue: () => R

    Returns R

reduce

  • reduce<T>(reducer: (accumulator: T, value: R) => T, initialValue: T): T

  • Takes a reducer and an initial value and returns the initial value if this is Left or the result of applying the function to the initial value and the value inside this

    Type Parameters

    • T

    Parameters

    • reducer: (accumulator: T, value: R) => T
    • initialValue: T

    Returns T

swap

toJSON

  • toJSON(): L | R

  • Returns L | R

toMaybe

  • toMaybe(): functional.Maybe<R>

  • Constructs a Just with the value of this if it's Right or a Nothing if this is Left

    Returns functional.Maybe<R>

toString

  • toString(): string

  • Returns string

unsafeCoerce

  • unsafeCoerce(): R

  • Returns the value inside this if it's a Right or either throws the value or a generic exception depending on whether the value is an Error

    Returns R

Settings

Member Visibility

On This Page

Methods