Variable FPromise

Type declaration

• • <T extends unknown, E = unknown>(
        executor: (
            resolve: (value: T | PromiseLike<T>) => void,
            reject: (reason?: E) => void,
        ) => void,
    ): FPromise<T, E>

  • Creates an FPromise from an executor function.

    Type Parameters

    • T extends unknown

      The type of the value that the FPromise resolves to
    • E = unknown

      The type of the error that the FPromise may reject with

    Parameters

    • executor: (
          resolve: (value: T | PromiseLike<T>) => void,
          reject: (reason?: E) => void,
      ) => void

      A function that receives resolve and reject functions

    Returns FPromise<T, E>

    An FPromise instance

    Example

    const promise = FPromise<number, Error>((resolve, reject) => {
      if (Math.random() > 0.5) {
        resolve(42);
      } else {
        reject(new Error("Something went wrong"));
      }
    });
    Copy

• all: <T, E = unknown>(
      promises: (T | FPromise<T, E> | PromiseLike<T>)[],
  ) => FPromise<T[], E>

  Runs multiple FPromises in parallel and returns an array of results. Similar to Promise.all, this will reject if any of the promises reject.

  Example

  const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
  const result = await FPromise.all(promises).toPromise()
  // result is [1, 2, 3]
  Copy

• allSettled: <T, E = unknown>(
      promises: (FPromise<T, E> | PromiseLike<T>)[],
  ) => FPromise<Either<E, T>[], never>

  Like Promise.allSettled, returns results of all promises whether they succeed or fail. This will always resolve, never reject.

  Example

  const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
  const result = await FPromise.allSettled(promises).toPromise()
  // result is [Right(1), Left(Error("Failed"))]
  Copy

• any: <T, E = unknown>(
      promises: (FPromise<T, E> | PromiseLike<T>)[],
  ) => FPromise<T, E>

  Like Promise.any, returns the first promise to fulfill. This will only reject if all promises reject.

  Example

  const promises = [
    FPromise.reject<number, Error>(new Error("First failed")),
    FPromise.resolve(2),
    FPromise.reject<number, Error>(new Error("Third failed"))
  ]
  const result = await FPromise.any(promises).toPromise()
  // result is 2
  Copy

• from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>

  Creates an FPromise from a regular Promise.

  Example

  const promise = FPromise.from(fetch("https://api.example.com/data"))
  // promise is an FPromise that resolves or rejects based on the fetch result
  Copy

• fromEither: <L, R>(either: Either<L, R>) => FPromise<R, L>

  Creates an FPromise from an Either. If the Either is a Right, the FPromise resolves with the Right value. If the Either is a Left, the FPromise rejects with the Left value.

  Example

  const either = Right<Error, number>(42)
  const promise = FPromise.fromEither(either)
  // promise resolves to 42
  Copy

• race: <T, E = unknown>(
      promises: (FPromise<T, E> | PromiseLike<T>)[],
  ) => FPromise<T, E>

  Like Promise.race, returns the first promise to settle (either resolve or reject).

  Example

  const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
  const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
  const result = await FPromise.race([slow, fast]).toPromise()
  // result is 2
  Copy

• reject: <T, E = unknown>(reason: E) => FPromise<T, E>

  Creates an FPromise that rejects with the provided reason.

  Example

  const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
  // promise rejects with Error("Something went wrong")
  Copy

• resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>

  Creates an FPromise that resolves to the provided value.

  Example

  const promise = FPromise.resolve(42)
  // promise resolves to 42
  Copy

• retryWithBackoff: <T, E = unknown>(
      operation: () => FPromise<T, E>,
      options: {
          baseDelay?: number;
          maxRetries: number;
          shouldRetry?: (error: E, attempt: number) => boolean;
      },
  ) => FPromise<T, E>

  Retries an operation with exponential backoff. This is useful for operations that may fail temporarily, such as network requests.

  Example

  const operation = () => {
    if (Math.random() > 0.8) {
      return FPromise.resolve("Success!")
    }
    return FPromise.reject<string, Error>(new Error("Temporary failure"))
  }
  
  const result = await FPromise.retryWithBackoff(operation, {
    maxRetries: 3,
    baseDelay: 100,
    shouldRetry: (error) => error.message === "Temporary failure"
  }).toPromise()
  Copy