Result.ts — react Source File

Source Code

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

// Direct translation of Rust's Result type, although some ownership related methods are omitted.
export interface Result<T, E> {
  /*
   * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,
   * leaving an `Err` value untouched.
   *
   * This function can be used to compose the results of two functions.
   */
  map<U>(fn: (val: T) => U): Result<U, E>;
  /*
   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,
   * leaving an `Ok` value untouched.
   *
   * This function can be used to pass through a successful result while handling an error.
   */
  mapErr<F>(fn: (val: E) => F): Result<T, F>;
  /*
   * Returns the provided default (if `Err`), or applies a function to the contained value
   * (if `Ok`).
   *
   * Arguments passed to {@link mapOr} are eagerly evaluated; if you are passing the result of a
   * function call, it is recommended to use {@link mapOrElse}, which is lazily evaluated.
   */
  mapOr<U>(fallback: U, fn: (val: T) => U): U;
  /*
   * Maps a `Result<T, E>` to `U` by applying fallback function default to a contained `Err` value,
   * or function `fn` to a contained `Ok` value.
   *
   * This function can be used to unpack a successful result while handling an error.
   */
  mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U;
  /*
   * Calls `fn` if the result is `Ok`, otherwise returns the `Err` value of self.
   *
   * This function can be used for control flow based on Result values.
   */
  andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>;
  /*
   * Returns res if the result is `Ok`, otherwise returns the `Err` value of self.
   *
   * Arguments passed to {@link and} are eagerly evaluated; if you are passing the result of a
   * function call, it is recommended to use {@link andThen}, which is lazily evaluated.
   */
  and<U>(res: Result<U, E>): Result<U, E>;
  /*
   * Returns `res` if the result is `Err`, otherwise returns the `Ok` value of self.
   *
   * Arguments passed to {@link or} are eagerly evaluated; if you are passing the result of a
   * function call, it is recommended to use {@link orElse}, which is lazily evaluated.
   */
  or(res: Result<T, E>): Result<T, E>;
  /*
   * Calls `fn` if the result is `Err`, otherwise returns the `Ok` value of self.
// ... (183 more lines)