Interface EitherAsync<L, R>

then

alt

• alt(other: functional.EitherAsync<L, R>): functional.EitherAsync<L, R>

• Returns the first Right between the future value of this and another EitherAsync or the Left in the argument if both this and the argument resolve to Left

  Parameters

  • other: functional.EitherAsync<L, R>

  Returns functional.EitherAsync<L, R>

ap

• ap<L2, R2>(
      other: PromiseLike<functional.Either<L2, (value: R) => R2>>,
  ): functional.EitherAsync<L | L2, Awaited<R2>>

• Applies a Right function wrapped in EitherAsync over a future Right value. Returns Left if either the this resolves to a Left or the function is Left

  Type Parameters

  • L2
  • R2

  Parameters

  • other: PromiseLike<functional.Either<L2, (value: R) => R2>>

  Returns functional.EitherAsync<L | L2, Awaited<R2>>

bimap

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

• Given two functions, maps the value that the Promise inside this resolves to using the first if it is Left or using the second one if it is Right

  Type Parameters

  • L2
  • R2

  Parameters

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

  Returns functional.EitherAsync<Awaited<L2>, Awaited<R2>>

caseOf

• caseOf<T>(patterns: functional.EitherPatterns<L, R, T>): Promise<T>

• Structural pattern matching for EitherAsync in the form of a function

  Type Parameters

  • T

  Parameters

  • patterns: functional.EitherPatterns<L, R, T>

  Returns Promise<T>

chain

• chain<L2, R2>(
      f: (value: R) => PromiseLike<functional.Either<L2, R2>>,
  ): functional.EitherAsync<L | L2, R2>

• Transforms this with a function that returns a EitherAsync. Behaviour is the same as the regular Either#chain

  Type Parameters

  • L2
  • R2

  Parameters

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

  Returns functional.EitherAsync<L | L2, R2>

chainLeft

• chainLeft<L2, R2>(
      f: (value: L) => PromiseLike<functional.Either<L2, R2>>,
  ): functional.EitherAsync<L2, R | R2>

• The same as EitherAsync#chain but executes the transformation function only if the value is Left. Useful for recovering from errors

  Type Parameters

  • L2
  • R2

  Parameters

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

  Returns functional.EitherAsync<L2, R | R2>

extend

• extend<R2>(
      f: (value: functional.EitherAsync<L, R>) => R2,
  ): functional.EitherAsync<L, Awaited<R2>>

• Returns this if it resolves to a Left, otherwise it returns the result of applying the function argument to this and wrapping it in a Right

  Type Parameters

  • R2

  Parameters

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

  Returns functional.EitherAsync<L, Awaited<R2>>

fantasy-land/alt

• "fantasy-land/alt"(
      other: functional.EitherAsync<L, R>,
  ): functional.EitherAsync<L, R>

• Parameters

  • other: functional.EitherAsync<L, R>

  Returns functional.EitherAsync<L, R>

fantasy-land/chain

• "fantasy-land/chain"<R2>(
      f: (value: R) => PromiseLike<functional.Either<L, R2>>,
  ): functional.EitherAsync<L, R2>

• Type Parameters

  • R2

  Parameters

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

  Returns functional.EitherAsync<L, R2>

finally

• finally(effect: () => any): functional.EitherAsync<L, R>

• Parameters

  • effect: () => any

  Returns functional.EitherAsync<L, R>

ifLeft

• ifLeft(effect: (value: L) => any): functional.EitherAsync<L, R>

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

  Parameters

  • effect: (value: L) => any

  Returns functional.EitherAsync<L, R>

ifRight

• ifRight(effect: (value: R) => any): functional.EitherAsync<L, R>

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

  Parameters

  • effect: (value: R) => any

  Returns functional.EitherAsync<L, R>

join

• join<L2, R2>(
      this: functional.EitherAsync<L, functional.Either<L2, R2>>,
  ): functional.EitherAsync<L | L2, R2>

• Flattens an Either nested inside an EitherAsync. e.join() is equivalent to e.chain(async x => x)

  Type Parameters

  • L2
  • R2

  Parameters

  • this: functional.EitherAsync<L, functional.Either<L2, R2>>

  Returns functional.EitherAsync<L | L2, R2>

leftOrDefault

• leftOrDefault(defaultValue: L): Promise<L>

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

  Parameters

  • defaultValue: L

  Returns Promise<L>

map

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

• Transforms the Right value of this with a given function. If the EitherAsync that is being mapped resolves to a Left then the mapping function won't be called and run will resolve the whole thing to that Left, just like the regular Either#map

  Type Parameters

  • R2

  Parameters

  • f: (value: R) => R2

  Returns functional.EitherAsync<L, Awaited<R2>>

mapLeft

• mapLeft<L2>(f: (value: L) => L2): functional.EitherAsync<Awaited<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.EitherAsync<Awaited<L2>, R>

orDefault

• orDefault(defaultValue: R): Promise<R>

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

  Parameters

  • defaultValue: R

  Returns Promise<R>

run

• run(): Promise<functional.Either<L, R>>

• It's important to remember how run will behave because in an async context there are other ways for a function to fail other than to return a Nothing, for example: If any of the computations inside EitherAsync resolved to a Left, run will return a Promise resolved to that Left. If any of the promises were to be rejected then run will return a Promise resolved to a Left with the rejection value inside If an exception is thrown then run will return a Promise resolved to a Left with the exception inside If none of the above happen then a promise resolved to the returned value wrapped in a Right will be returned

  Returns Promise<functional.Either<L, R>>

swap

• swap(): functional.EitherAsync<R, L>

• Returns Right if this is Left and vice versa

  Returns functional.EitherAsync<R, L>

toMaybeAsync

• toMaybeAsync(): functional.MaybeAsync<R>

• Converts this to a MaybeAsync, discarding any error values

  Returns functional.MaybeAsync<R>

void

• void(): functional.EitherAsync<L, void>

• Useful if you are not interested in the result of an operation

  Returns functional.EitherAsync<L, void>