Variable TaskConst

Type Declaration

• • <T = unknown>(
        params?: TaskParams,
    ): {
        _tag: string;
        _type: string;
        Async: <U = T>(
            t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,
            e?: (error: unknown) => unknown,
            f?: () => void | Promise<void>,
            cancellationToken?: CancellationToken,
        ) => FPromise<TaskOutcome<U>>;
        AsyncWithProgress: <U = T>(
            t: (
                updateProgress: (percent: number) => void,
            ) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,
            onProgress: (percent: number) => void,
            e?: (error: unknown) => unknown,
            f?: () => void | Promise<void>,
            cancellationToken?: CancellationToken,
        ) => FPromise<TaskOutcome<U>>;
        Sync: <U = T>(
            t: () => U,
            e?: (error: unknown) => unknown,
            f?: () => void,
        ) => TaskOutcome<U>;
        doUnwrap(): DoResult<unknown>;
        toString(): string;
    }

  • Task adapter for bridging promise-based code with functional error handling patterns

    Type Parameters

    • T = unknown

    Parameters

    • Optionalparams: TaskParams

    Returns {
        _tag: string;
        _type: string;
        Async: <U = T>(
            t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,
            e?: (error: unknown) => unknown,
            f?: () => void | Promise<void>,
            cancellationToken?: CancellationToken,
        ) => FPromise<TaskOutcome<U>>;
        AsyncWithProgress: <U = T>(
            t: (
                updateProgress: (percent: number) => void,
            ) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,
            onProgress: (percent: number) => void,
            e?: (error: unknown) => unknown,
            f?: () => void | Promise<void>,
            cancellationToken?: CancellationToken,
        ) => FPromise<TaskOutcome<U>>;
        Sync: <U = T>(
            t: () => U,
            e?: (error: unknown) => unknown,
            f?: () => void,
        ) => TaskOutcome<U>;
        doUnwrap(): DoResult<unknown>;
        toString(): string;
    }

    • Readonly_tag: string

    • _type: string

    • Async: <U = T>(
          t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,
          e?: (error: unknown) => unknown,
          f?: () => void | Promise<void>,
          cancellationToken?: CancellationToken,
      ) => FPromise<TaskOutcome<U>>

      Run an async operation with explicit try/catch/finally semantics Returns a raw Promise that can interact with traditional Promise-based code

    • AsyncWithProgress: <U = T>(
          t: (
              updateProgress: (percent: number) => void,
          ) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,
          onProgress: (percent: number) => void,
          e?: (error: unknown) => unknown,
          f?: () => void | Promise<void>,
          cancellationToken?: CancellationToken,
      ) => FPromise<TaskOutcome<U>>

      Run an async operation with progress tracking capabilities Returns a Promise and provides progress updates via callback

    • Sync: <U = T>(
          t: () => U,
          e?: (error: unknown) => unknown,
          f?: () => void,
      ) => TaskOutcome<U>

      Run a synchronous operation with explicit try/catch/finally semantics Returns a TaskOutcome for functional error handling

    • doUnwrap: function

      • doUnwrap(): DoResult<unknown>

        Returns DoResult<unknown>

    • toString: function

      • toString(): string

        Returns string

• cancellable: <T>(
      task: (token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>,
      params?: TaskParams,
  ) => { cancel: () => void; task: FPromise<TaskOutcome<T>> }

  Create a task that can be cancelled

• createCancellationTokenSource: () => CancellationTokenSource

  Create a cancellation token source

  Returns

  A cancellation token source that can be used to control task cancellation

• err: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>

  Create a failed Task result (alias for fail) Preferred for new code

• fail: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>

  Create a failed Task result

• formatErrorChain: (
      error: Error | undefined,
      options?: {
          includeStackTrace?: boolean;
          includeTasks?: boolean;
          separator?: string;
      },
  ) => string

  Format the error chain as a string with the option to include task details

• fromEither: <T>(either: Either<Throwable, T>, params?: TaskParams) => TaskOutcome<T>

  Create TaskOutcome from Either

• fromNodeCallback: <T, Args extends unknown[]>(
      nodeFn: (
          ...args: [...Args[], (error: unknown, result: T) => void],
      ) => void,
      params?: TaskParams,
  ) => (...args: Args) => FPromise<TaskOutcome<T>>

  Convert a Node.js style callback function to a Task-compatible function Node.js callbacks typically have the signature (error, result) => void

• fromPromise: <U, Args extends unknown[]>(
      promiseFn: (...args: Args) => Promise<U>,
      params?: TaskParams,
  ) => (...args: Args) => FPromise<TaskOutcome<U>>

  Convert a Promise-returning function to a Task-compatible function

• fromTry: <T>(tryValue: Try<T>, params?: TaskParams) => TaskOutcome<T>

  Create TaskOutcome from Try

• getErrorChain: (error: Error | undefined) => Error[]

  Extract the error chain from a Throwable error Returns an array of errors from outermost to innermost

• ok: <T>(data: T, params?: TaskParams) => Ok<T>

  Create a successful Task result (alias for success) Preferred for new code

• race: <T>(
      tasks: (FPromise<T> | FPromise<TaskOutcome<T>>)[],
      timeoutMs?: number,
      params?: TaskParams,
  ) => FPromise<TaskOutcome<T>>

  Race multiple tasks and return the result of the first one to complete Optionally specify a timeout after which the race will fail

• success: <T>(data: T, params?: TaskParams) => Ok<T>

  Create a successful Task result

• toPromise: <U>(taskOutcome: TaskOutcome<U>) => Promise<U>

  Convert a Task result to a Promise

• withProgress: <T>(
      task: (
          updateProgress: (percent: number) => void,
          token: CancellationToken,
      ) => Promise<T> | Promise<TaskOutcome<T>>,
      onProgress?: (percent: number) => void,
      params?: TaskParams,
  ) => {
      cancel: () => void;
      currentProgress: () => number;
      task: FPromise<TaskOutcome<T>>;
  }

  Creates a task with progress tracking