Variable Either

Type Declaration

• • <L extends unknown, R extends unknown>(
        value: L | R,
        isRight: boolean,
    ): Either<L, R>

  • Either constructor that creates Left or Right based on the isRight parameter

    Type Parameters

    • L extends unknown
    • R extends unknown

    Parameters

    • value: L | R

      The value to wrap

    • isRight: boolean

      If true, creates Right, otherwise creates Left

    Returns Either<L, R>

    Either instance

• ap: <L extends unknown, R extends unknown, U extends unknown>(
      eitherF: Either<L, (value: R) => U>,
      eitherV: Either<L, R>,
  ) => Either<L, U>

  Applicative apply - applies a wrapped function to a wrapped value

• fromBinary: <L extends unknown, R extends unknown>(binary: string) => Either<L, R>

  Creates an Either from binary string

• fromJSON: <L extends unknown, R extends unknown>(json: string) => Either<L, R>

  Creates an Either from JSON string

• fromNullable: <L extends unknown, R extends unknown>(
      value: R | null | undefined,
      leftValue: L,
  ) => Either<L, R>

  Creates an Either from a nullable value

• fromPredicate: <L extends unknown, R extends unknown>(
      value: R,
      predicate: (value: R) => boolean,
      leftValue: L,
  ) => Either<L, R>

  Creates an Either based on a predicate

• fromPromise: <L, R>(
      promise: Promise<R>,
      onRejected: (reason: unknown) => L,
  ) => Promise<Either<L, R>>

  Creates an Either from a Promise

• fromYAML: <L extends unknown, R extends unknown>(yaml: string) => Either<L, R>

  Creates an Either from YAML string

• isLeft: <L extends unknown, R extends unknown>(
      either: Either<L, R>,
  ) => either is LeftOf<L, R>

  Type guard to check if an Either is Left

• isRight: <L extends unknown, R extends unknown>(
      either: Either<L, R>,
  ) => either is RightOf<L, R>

  Type guard to check if an Either is Right

• left: <L extends unknown, R extends unknown>(value: L) => Either<L, R>

  Creates a Left instance

• right: <L extends unknown, R extends unknown>(value: R) => Either<L, R>

  Creates a Right instance

• sequence: <L extends unknown, R extends unknown>(
      eithers: readonly Either<L, R>[],
  ) => Either<L, R[]>

  Combines an array of Eithers into a single Either containing an array

• traverse: <L extends unknown, R extends unknown, U extends unknown>(
      arr: readonly R[],
      f: (value: R, index: number) => Either<L, U>,
  ) => Either<L, U[]>

  Maps an array through a function that returns Either, then sequences the results. Short-circuits on the first Left: f is not called for the elements after it.

• traverseAsync: <L extends unknown, A extends unknown, U extends unknown>(
      items: Iterable<A>,
      f: (value: A) => PromiseLike<Either<L, U>>,
      options?: ConcurrencyOptions,
  ) => Promise<Either<L, U[]>>

  Async traverse: runs f over items and collects the Right values, stopping at the first Left.

  Runs one call at a time, in order, by default. Pass { concurrency: n } to allow up to n calls at once, or "unbounded" to start them all together. After a Left no new calls start; calls already running finish, and the result is the Left of the earliest item that failed. A rejected promise rejects the result.

  Example

  const saved = await Either.traverseAsync(rows, (row) => saveRow(row))
  // Either<SaveError, SavedRow[]>, one save at a time, stopping at the first failure
  
  const fetched = await Either.traverseAsync(ids, fetchUser, { concurrency: 4 })
  Copy

• void: <L extends unknown>() => Either<L, void>

  Creates a Right<L, void> — convenience for "operation succeeded with no meaningful value". Avoids variance quirks around Either<L, void> vs Either<L, undefined>.