t-tasks
    Preparing search index...

    Interface Task<R>

    Task monad interface

    interface Task<R> {
        cancel: () => boolean;
        generator: TaskGeneratorFunction<[], unknown, Task<R>, R>;
        reject: (error: any) => boolean;
        resolve: () => TaskInvoke<R>;
        resolved: () => Cancelable<R> | null;
        _cancel(error: Maybe<any>): boolean;
        _invoke(op: (result: Cancelable<R>) => void): void;
        chain<R2>(op: (value: R) => Task<R2>): Task<R2>;
        chainCanceled<R2>(op: () => Task<R2>): Task<R | R2>;
        chainRejected<R2>(op: (error: any) => Task<R2>): Task<R | R2>;
        map<R2>(op: (value: R) => R2): Task<R2>;
        mapCanceled<R2>(op: () => R2): Task<R | R2>;
        mapRejected<R2>(op: (error: any) => R2): Task<R | R2>;
        matchChain<R2, R3 = R2, R4 = R3>(
            op: {
                canceled: () => Task<R4>;
                rejected: (error: any) => Task<R3>;
                resolved: (value: R) => Task<R2>;
            },
        ): Task<R2 | R3 | R4>;
        matchMap<R2, R3 = R2, R4 = R3>(
            op: {
                canceled: () => R4;
                rejected: (error: any) => R3;
                resolved: (value: R) => R2;
            },
        ): Task<R2 | R3 | R4>;
        matchTap(
            op: {
                canceled: () => void;
                rejected: (error: any) => void;
                resolved: (value: R) => void;
            },
        ): Task<R>;
        tap(op: (value: R) => void): Task<R>;
        tapCanceled(op: () => void): Task<R>;
        tapRejected(op: (error: any) => void): Task<R>;
    }

    Type Parameters

    • R

      task resolve type

    Hierarchy

    • TaskBase<R>
      • Task
    Index

    Properties

    cancel generator reject resolve resolved

    Methods

    _cancel _invoke chain chainCanceled chainRejected map mapCanceled mapRejected matchChain matchMap matchTap tap tapCanceled tapRejected

    Properties

    cancel: () => boolean

    Invoke underlying cancel method without error

    Type Declaration

      • (): boolean

      • Returns boolean

        'true' when the task was still pending and cancelation was applied

    generator: TaskGeneratorFunction<[], unknown, Task<R>, R>

    Wrap task to singleton generator

    Userful in order to avoid ambiguous yied types

    generator of task wrapping the task

    const getString = () => Task.resolved('hello');
    const getLength = (data: string) => Task.resolved(data.length);

    // ..... //

    Task.generate(function* () {
      const data = yield getString(); // data: string | number
      const length = yield getLength(data); // length: string | number

      return length;
    });

    // ..... //

    Task.generate(function* () {
      const data = yield* getString().generator(); // data: string
      const length = yield* getLength(data).generator(); // length: number

      return length;
    });
    reject: (error: any) => boolean

    Invoke underlying cancel method with error

    Type Declaration

      • (error: any): boolean

      • Parameters

        • error: any

          error value to be injected from outside

        Returns boolean

        'true' when the task was still pending and the error was applied

    resolve: () => TaskInvoke<R>

    Return underlying promise in order to await result

    Type Declaration

      • (): TaskInvoke<R>

      • Returns TaskInvoke<R>

        underlying promise

    resolved: () => Cancelable<R> | null

    Read the settled result when the task has already finished

    Type Declaration

    Methods

    _cancel

    • _cancel(error: Maybe<any>): boolean

      Parameters

      Returns boolean

    _invoke

    • Invoke transformer when task is resolved (and only then) and continue execution with it's result

      Type Parameters

      • R2

        transformer task resolve type

      Parameters

      • op: (value: R) => Task<R2>

        transformer to invoke

      Returns Task<R2>

      task chaining to transformer result task

    • Invoke transformer when task is canceled (and only then) and continue execution with it's result

      Type Parameters

      • R2

        fallback task resolve type

      Parameters

      • op: () => Task<R2>

        transformer to invoke

      Returns Task<R | R2>

      task chaining to fallback task in case of cancelation

    • Invoke transformer when task is rejected (and only then) and continue execution with it's result

      Type Parameters

      • R2

        fallback task resolve type

      Parameters

      • op: (error: any) => Task<R2>

        transformer to invoke

      Returns Task<R | R2>

      task chaining to fallback task in case of failure

    • Invoke transformer when task is resolved (and only then) and return it's result instead

      Type Parameters

      • R2

        transformer return type

      Parameters

      • op: (value: R) => R2

        transformer to invoke

      Returns Task<R2>

      task returning transformer result

    • Invoke transformer when task is canceled (and only then) and return it's result instead

      Type Parameters

      • R2

        fallback return type

      Parameters

      • op: () => R2

        transformer to invoke

      Returns Task<R | R2>

      task returning fallback result in case of cancelation

    • Invoke transformer when task is rejected (and only then) and return it's result instead

      Type Parameters

      • R2

        fallback return type

      Parameters

      • op: (error: any) => R2

        transformer to invoke

      Returns Task<R | R2>

      task returning fallback result in case of failure

    • Invoke a dedicated transformer according to task resolution and continue execution with it's result

      Type Parameters

      • R2

        success transformer resolve type

      • R3 = R2

        failure transformer resolve type

      • R4 = R3

        cancelation transformer resolve type

      Parameters

      • op: {
            canceled: () => Task<R4>;
            rejected: (error: any) => Task<R3>;
            resolved: (value: R) => Task<R2>;
        }
        • canceled: () => Task<R4>

          transformer to invoke on cancelation

        • rejected: (error: any) => Task<R3>

          transformer to invoke on failure

        • resolved: (value: R) => Task<R2>

          transformer to invoke on success

      Returns Task<R2 | R3 | R4>

      task chaining to a corresponding transformer result

    • Invoke a dedicated transformer according to task resolution

      Type Parameters

      • R2

        success transformer return type

      • R3 = R2

        failure transformer return type

      • R4 = R3

        cancelation transformer return type

      Parameters

      • op: { canceled: () => R4; rejected: (error: any) => R3; resolved: (value: R) => R2 }
        • canceled: () => R4

          transformer to invoke on cancelation

        • rejected: (error: any) => R3

          transformer to invoke on failure

        • resolved: (value: R) => R2

          transformer to invoke on success

      Returns Task<R2 | R3 | R4>

      task resolving to a corresponding transformer result

    • Invoke a dedicated callback according to task resolution

      Parameters

      • op: {
            canceled: () => void;
            rejected: (error: any) => void;
            resolved: (value: R) => void;
        }
        • canceled: () => void

          callback to invoke on cancelation

        • rejected: (error: any) => void

          callback to invoke on failure

        • resolved: (value: R) => void

          callback to invoke on success

      Returns Task<R>

      self

    • Invoke callback when task is resolved (and only then)

      Parameters

      • op: (value: R) => void

        callback to invoke

      Returns Task<R>

      self

    • Invoke callback when task is canceled (and only then)

      Parameters

      • op: () => void

        callback to invoke

      Returns Task<R>

      self

    • Invoke callback when task is rejected (and only then)

      Parameters

      • op: (error: any) => void

        callback to invoke

      Returns Task<R>

      self

    Settings

    Member Visibility

    On This Page

    Properties
    Methods