t-tasks 2.0.0 → 2.1.0

package/src/either.ts

@@ -64,6 +64,7 @@ export interface Right<R, L> {
    * Applied to 'right value' returns self without invoking transformer
    * Applied to 'left error' returns 'right op(error)'
    *
+   * @template R2 transformer function's return type
    * @param op transformer to be invoked with underlying error
    * @returns 'right value' or 'right op(error)'
    */
@@ -89,6 +90,18 @@ export interface Right<R, L> {
   // General case
   match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 | R3;
 
+  /**
+   * Either pattern matching transformer function
+   *
+   * Applied to 'right value' returns 'right op.right(value)'
+   * Applied to 'left error' returns 'right op.left(error)'
+   *
+   * @template R2 right transformer function's return type
+   * @template R3 left transformer function's return type
+   * @param op.right transformer to be invoked with underlying value in case of 'right'
+   * @param op.left transformer to be invoked with underlying error in case of 'left'
+   * @returns 'right op.right(value)' or 'right op.left(error)'
+   */
   // Right case
   matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2, never>;
   // General case
@@ -115,7 +128,7 @@ export interface Right<R, L> {
   chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;
 
   /**
-   * Either composition function
+   * Either fallback composition function
    *
    * Applied to 'right value' returns self without invoking composition function
    * Applied to 'left error' returns 'op(error)'
@@ -146,7 +159,7 @@ export interface Right<R, L> {
    * @template L3 left transformer function result's underlying error type
    * @param op.right transformer to be invoked with underlying value in case of 'right'
    * @param op.left transformer to be invoked with underlying error in case of 'left'
-   * @returns 'op(value)' or 'op(error)'
+   * @returns 'op.right(value)' or 'op.left(error)'
    */
   // Right cases
   matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2, never>;
@@ -273,6 +286,7 @@ export interface Left<R, L> {
    * Applied to 'right value' returns self without invoking transformer
    * Applied to 'left error' returns 'right op(error)'
    *
+   * @template R2 transformer function's return type
    * @param op transformer to be invoked with underlying error
    * @returns 'right value' or 'right op(error)'
    */
@@ -298,6 +312,18 @@ export interface Left<R, L> {
   // General case
   match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 | R3;
 
+  /**
+   * Either pattern matching transformer function
+   *
+   * Applied to 'right value' returns 'right op.right(value)'
+   * Applied to 'left error' returns 'right op.left(error)'
+   *
+   * @template R2 right transformer function's return type
+   * @template R3 left transformer function's return type
+   * @param op.right transformer to be invoked with underlying value in case of 'right'
+   * @param op.left transformer to be invoked with underlying error in case of 'left'
+   * @returns 'right op.right(value)' or 'right op.left(error)'
+   */
   // Left case
   matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R3, never>;
   // General case
@@ -355,7 +381,7 @@ export interface Left<R, L> {
    * @template L3 left transformer function result's underlying error type
    * @param op.right transformer to be invoked with underlying value in case of 'right'
    * @param op.left transformer to be invoked with underlying error in case of 'left'
-   * @returns 'op(value)' or 'op(error)'
+   * @returns 'op.right(value)' or 'op.left(error)'
    */
   // Left cases
   matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;
@@ -459,7 +485,23 @@ export namespace Left {
   }
 }
 
+/**
+ * Either generator
+ *
+ * @template T yielded underlying type
+ * @template TT yielded Either type
+ * @template R returned underlying type
+ */
 export type EitherGenerator<T, TT extends Either<T, any>, R> = Generator<TT, R, T>;
+
+/**
+ * Function returning Either generator (generator function)
+ *
+ * @template A argument types
+ * @template T yielded underlying type
+ * @template TT yielded Either type
+ * @template R returned underlying type
+ */
 export type EitherGeneratorFunction<A extends unknown[], T, TT extends Either<T, any>, R> = (...args: A) => EitherGenerator<T, TT, R>;
 
 export namespace Either {
@@ -490,6 +532,8 @@ export namespace Either {
    *
    * Resolves to 'left error' in case of undefined value and 'right value' otherwise
    *
+   * @template R underlying value type
+   * @template L underlying error type
    * @param value possibly undefined value
    * @param error error to use in case of undefined value
    * @returns either 'right value' or 'left error'
@@ -506,8 +550,10 @@ export namespace Either {
    *
    * Resolves to 'left error' in case of undefined or null value and 'right value' otherwise
    *
-   * @param value possibly undefined or nullable value
-   * @param error error to use in case of undefined or nullable value
+   * @template R underlying value type
+   * @template L underlying error type
+   * @param value possibly undefined or null value
+   * @param error error to use in case of undefined or null value
    * @returns either 'right value' or 'left error'
    */
   export function fromNullable<L>(value: undefined, error: L): Left<never, L>;
@@ -544,6 +590,7 @@ export namespace Either {
    * Useful for passing as a predicate to collection transformers
    *
    * @template R underlying value type
+   * @template L underlying error type
    * @param either Either instance
    * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')
    */
@@ -557,6 +604,7 @@ export namespace Either {
    * Useful for passing as a predicate to collection transformers
    *
    * @template R underlying value type
+   * @template L underlying error type
    * @param either Either instance
    * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')
    */
@@ -567,6 +615,8 @@ export namespace Either {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
+   * @template L underlying error type
    * @param eithers a list of Either
    * @returns true in case every list element is Right
    */
@@ -577,6 +627,8 @@ export namespace Either {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
+   * @template L underlying error type
    * @param eithers a list of Either
    * @returns true in case at least one list element is Right
    */
@@ -587,6 +639,8 @@ export namespace Either {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
+   * @template L underlying error type
    * @param eithers a list of Either
    * @returns true in case every list element is Left
    */
@@ -597,6 +651,8 @@ export namespace Either {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
+   * @template L underlying error type
    * @param eithers a list of Either
    * @returns true in case at least one list element is Left
    */
@@ -610,6 +666,7 @@ export namespace Either {
    * Applying yield to an Either within the generator function unwraps the Either and returns underlying value in case of success
    * However the convenient option for typescript is to use ```yield* either.generator()``` as otherwise one may have to deal with union types
    *
+   * @template T yielded underlying type
    * @template TT yielded Either type
    * @template R returned underlying type
    * @param eitherGeneratorFunction Either generator function

package/src/maybe.ts

@@ -63,6 +63,7 @@ export interface Just<R> {
    * Applied to 'just value' returns self without invoking transformer
    * Applied to 'nothing' returns 'just op()'
    *
+   * @template R2 transformer function's return type
    * @param op function to be invoked
    * @returns 'just value' or 'just op()'
    */
@@ -88,7 +89,19 @@ export interface Just<R> {
   // General case
   match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 | R3;
 
-  // Nothing cases
+  /**
+   * Maybe pattern matching transformer function
+   *
+   * Applied to 'just value' returns 'just op.just(value)'
+   * Applied to 'nothing' returns 'just op.nothing()'
+   *
+   * @template R2 just transformer function's return type
+   * @template R3 nothing transformer function's return type
+   * @param op.just transformer to be invoked with underlying value in case of just
+   * @param op.nothing transformer to be invoked in case of nothing
+   * @returns 'just op.just(value)' or 'just op.nothing()'
+   */
+  // Just cases
   matchMap<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2>;
   // General case
   matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;
@@ -207,6 +220,8 @@ export interface Just<R> {
  * Absolutely Nothing
  *
  * Maybe data type specialization representing an absence of any value
+ *
+ * @template R underlying value
  */
 export interface Nothing<R> {
   /**
@@ -264,6 +279,7 @@ export interface Nothing<R> {
    * Applied to 'just value' returns self without invoking transformer
    * Applied to 'nothing' returns 'just op()'
    *
+   * @template R2 transformer function's return type
    * @param op function to be invoked
    * @returns 'just value' or 'just op()'
    */
@@ -289,7 +305,19 @@ export interface Nothing<R> {
   // General case
   match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 | R3;
 
-  // Just cases
+  /**
+   * Maybe pattern matching transformer function
+   *
+   * Applied to 'just value' returns 'just op.just(value)'
+   * Applied to 'nothing' returns 'just op.nothing()'
+   *
+   * @template R2 just transformer function's return type
+   * @template R3 nothing transformer function's return type
+   * @param op.just transformer to be invoked with underlying value in case of just
+   * @param op.nothing transformer to be invoked in case of nothing
+   * @returns 'just op.just(value)' or 'just op.nothing()'
+   */
+  // Nothing cases
   matchMap<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R3>;
   // General case
   matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;
@@ -430,7 +458,23 @@ export namespace Just {
 
 export namespace Nothing {}
 
+/**
+ * Maybe generator
+ *
+ * @template T yielded underlying type
+ * @template TT yielded Maybe type
+ * @template R returned underlying type
+ */
 export type MaybeGenerator<T, TT extends Maybe<T>, R> = Generator<TT, R, T>;
+
+/**
+ * Function returning Maybe generator (generator function)
+ *
+ * @template A argument types
+ * @template T yielded underlying type
+ * @template TT yielded Maybe type
+ * @template R returned underlying type
+ */
 export type MaybeGeneratorFunction<A extends unknown[], T, TT extends Maybe<T>, R> = (...args: A) => MaybeGenerator<T, TT, R>;
 
 export namespace Maybe {
@@ -459,6 +503,7 @@ export namespace Maybe {
    *
    * Resolves to 'nothing' in case of undefined value and 'just value' otherwise
    *
+   * @template R underlying type
    * @param value possibly undefined value
    * @returns either 'just value' or 'nothing'
    */
@@ -474,7 +519,8 @@ export namespace Maybe {
    *
    * Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise
    *
-   * @param value possibly undefined value
+   * @template R underlying type
+   * @param value possibly undefined or null value
    * @returns either 'just value' or 'nothing'
    */
   export function fromNullable(value: undefined): Nothing<never>;
@@ -533,6 +579,7 @@ export namespace Maybe {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
    * @param maybes a list of Maybe
    * @returns true in case every list element is Just
    */
@@ -543,6 +590,7 @@ export namespace Maybe {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
    * @param maybes a list of Maybe
    * @returns true in case at least one list element is Just
    */
@@ -553,6 +601,7 @@ export namespace Maybe {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
    * @param maybes a list of Maybe
    * @returns true in case every list element is Nothing
    */
@@ -563,6 +612,7 @@ export namespace Maybe {
   /**
    * Standalone list predicate
    *
+   * @template R underlying value type
    * @param maybes a list of Maybe
    * @returns true in case at least one list element is Nothing
    */
@@ -576,6 +626,7 @@ export namespace Maybe {
    * Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success
    * However the convenient option for typescript is to use ```yield* maybe.generator()``` as otherwise one may have to deal with union types
    *
+   * @template T yielded underlying type
    * @template TT yielded Maybe type
    * @template R returned underlying type
    * @param maybeGeneratorFunction Maybe generator function

package/src/task.ts

@@ -26,6 +26,7 @@ export type TaskFunction<A extends unknown[], R> = (...args: A) => Task<R>;
 /**
  * Task generator
  *
+ * @template T yielded underlying type
  * @template TT yielded task type
  * @template R returned task resolve type
  *
@@ -44,6 +45,7 @@ export type TaskGenerator<T, TT extends Task<T>, R> = Generator<TT, R, T>;
  * Function returning task generator (generator function)
  *
  * @template A argument types
+ * @template T yielded underlying type
  * @template TT yielded task type
  * @template R returned task resolve type
  *
@@ -178,6 +180,11 @@ export interface Task<R> extends TaskBase<R> {
    */
   matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 | R3 | R4>;
 
+  /**
+   * Read the settled result when the task has already finished
+   *
+   * @returns settled result, or null when the task is still pending
+   */
   resolved: () => Cancelable<R> | null;
 
   /**
@@ -188,14 +195,17 @@ export interface Task<R> extends TaskBase<R> {
   resolve: () => TaskInvoke<R>;
 
   /**
-   * Invoke underlying canel method without error
+   * Invoke underlying cancel method without error
+   *
+   * @returns 'true' when the task was still pending and cancelation was applied
    */
   cancel: () => boolean;
 
   /**
-   * Invoke underlying canel method with error
+   * Invoke underlying cancel method with error
    *
    * @param error error value to be injected from outside
+   * @returns 'true' when the task was still pending and the error was applied
    */
   reject: (error: any) => boolean;
 
@@ -263,7 +273,7 @@ export namespace Task {
    *
    * @template R returned task's resolve type
    * @param error error to be returned upon awaiting
-   * @returns task resolving to specified value
+   * @returns task rejected with the specified error
    */
   export function rejected<R>(error: any): Task<R> {
     return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.left(error)) });
@@ -273,7 +283,7 @@ export namespace Task {
    * Invariant task constructor creating canceled task
    *
    * @template R returned task's resolve type
-   * @returns task resolving to specified value
+   * @returns canceled task
    */
   export function canceled<R>(): Task<R> {
     return new TaskClass<R>({ resolved: true, result: Maybe.nothing() });
@@ -350,10 +360,12 @@ export namespace Task {
   /**
    * Generic callback task
    *
-   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction
+   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFunction
    *
+   * @template H cancelation handler type
+   * @template R returned task resolve type
    * @param create task body with success and error callbacks
-   * @param cancel cancelation function intended for stopping task execution
+   * @param onCancel cancelation function intended for stopping task execution
    * @returns task resolving to success value
    *
    * @example
@@ -460,9 +472,8 @@ export namespace Task {
   /**
    * Convinience shortcut for yielding timers
    *
-   * @template R returned generator resolve type
-   * @param promise promise to be resolved
-   * @returns generator to be be used with yield*
+   * @param delay duration in ms after that the generator resolves
+   * @returns generator to be used with yield*
    */
    export function timeoutGenerator(delay: number) {
     return Task.timeout(delay).generator();
@@ -500,6 +511,7 @@ export namespace Task {
    *
    * If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately
    *
+   * @template T yielded underlying type
    * @template TT yielded task type
    * @template R returned task resolve type
    * @param taskGeneratorFunction task generator function
@@ -575,11 +587,12 @@ export namespace Task {
    * 
    * Simplifies wrighting functions returning generated tasks
    * 
-   * @template Args generator arguments
+   * @template A generator arguments
+   * @template T yielded underlying type
    * @template TT yielded task type
    * @template R returned task resolve type
    * @param taskGeneratorFunction function* (...args) task generator function
-   * @returns task resolving to generator's return type
+   * @returns task function resolving to generator's return type
    */
   export function generateFunction<A extends any[], T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<A, T, TT, R>): TaskFunction<A, R> {
     return (...args: A) => generate(() => taskGeneratorFunction(...args));
@@ -609,6 +622,7 @@ export namespace Task {
   /**
    * Start multiple tasks one after another
    *
+   * @template T underlying task type
    * @param taskFunctions list of task functions (without arguments)
    * @returns composite task invoring every task in order and resolving to the list of results
    */
@@ -631,7 +645,7 @@ export namespace Task {
    *
    * @template T underlying task type
    * @param tasks iterable of tasks to execute
-   * @retuirns task resolving to the list of results
+   * @returns task resolving to the list of results
    */
   export function all<T>(tasks: Iterable<Task<T>>) {
     const taskArray = Array.from(tasks);
@@ -677,7 +691,7 @@ export namespace Task {
    *
    * @template T underlying task type
    * @param tasks iterable of tasks to execute
-   * @retuirns task resolving to the result of first successfull task
+   * @returns task resolving to the result of first successfull task
    */
   export function any<T>(tasks: Iterable<Task<T>>) {
     const cell = settleCell<Cancelable<T>>();
@@ -722,6 +736,7 @@ export namespace Task {
    * If the second task resolves sooner than the first, resulting task is canceled
    * Otherwise the resulting task resolves together with the first one
    *
+   * @template T underlying task type
    * @param task task to limit
    * @param limitTask limiting task
    * @returns task limites according to limitTask
@@ -736,7 +751,9 @@ export namespace Task {
    * Given task is re-generated in case of failure (both external and internal)
    * Resulting task is still cancelable by standard means
    *
+   * @template T underlying task type
    * @param taskFunction task preoducing function
+   * @returns task that retries until the produced task resolves
    */
   export function repeat<T>(taskFunction: TaskFunction<[], T>) {
     const sequentor = (): Task<T> => taskFunction().chainRejected(sequentor);
@@ -806,7 +823,7 @@ const settleCell = <T>(): SettleCell<T> => {
   };
 };
 
-function chainTaskMaybe<R, R2>(parent: TaskBase<R>, op: (value: Cancelable<R>) => Task<R2>) {
+function chainTaskMaybe<R, R2>(parent: Task<R>, op: (value: Cancelable<R>) => Task<R2>): Task<R2> {
   const cell = settleCell<Cancelable<R2>>();
 
   let state:
@@ -862,36 +879,74 @@ function chainTaskMaybe<R, R2>(parent: TaskBase<R>, op: (value: Cancelable<R>) =
   });
 }
 
-function chainTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Task<R2>) {
-  return chainTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op).orMap<Task<R2>>(Task.canceled).just);
-}
+function mapTaskMaybe<R, R2>(parent: Task<R>, op: (value: Cancelable<R>) => Cancelable<R2>): Task<R2> {
+  const cell = settleCell<Cancelable<R2>>();
 
-function mapTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Cancelable<R2>) {
-  return chainTaskMaybe<R, R2>(_task, (maybe) => {
-    return op(maybe).match<Task<R2>>({
-      just: (either) =>
-        either.match<Task<R2>>({
-          right: Task.resolved,
-          left: Task.rejected,
-        }),
-      nothing: Task.canceled,
-    });
+  let state:
+    | { phase: 'parent' }
+    | { phase: 'transform', error: Maybe<any> | null }
+    | { phase: 'closed' } = { phase: 'parent' };
+
+  parent._invoke((result) => {
+    state = { phase: 'transform', error: null }
+
+    let value: Cancelable<R2> | null = null;
+    try {
+      value = op(result);
+    } catch (e) {
+      cell.resolve(Maybe.just(Either.left(e)));
+      state = { phase: 'closed' };
+      return;
+    }
+
+    const transformError = state.phase === 'transform' ? state.error : null;
+
+    if (transformError) {
+      cell.resolve(transformError.map(Either.left));
+    } else {
+      cell.resolve(value);
+    }
+    
+    state = { phase: 'closed' };
+  });
+
+  return Task.create(cell.promise, (error) => {
+    if (cell.settled()) {
+      return false;
+    }
+
+    if (state.phase === 'parent') {
+      return parent._cancel(error);
+    } else if (state.phase === 'transform') {
+      state.error = error;
+      return true;
+    } else {
+      return false;
+    }
   });
 }
 
-function mapTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Rejectable<R2>) {
-  return mapTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op));
+function tapTaskMaybe<R>(parent: Task<R>, op: (value: Cancelable<R>) => void): Task<R> {
+  parent._invoke((result) => {
+    try {
+      op(result);
+    } catch (e) {
+      reportError(e);
+    }
+  });
+
+  return parent;
 }
 
-function tapTaskMaybe<R>(_task: TaskBase<R>, op: (value: Cancelable<R>) => void) {
-  return mapTaskMaybe<R, R>(_task, (value) => {
-    op(value);
+function chainTaskEither<R, R2>(_task: Task<R>, op: (value: Rejectable<R>) => Task<R2>): Task<R2> {
+  return chainTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op).orMap<Task<R2>>(Task.canceled).just);
+}
 
-    return value;
-  });
+function mapTaskEither<R, R2>(_task: Task<R>, op: (value: Rejectable<R>) => Rejectable<R2>): Task<R2> {
+  return mapTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op));
 }
 
-function tapTaskEither<R>(_task: TaskBase<R>, op: (value: Rejectable<R>) => void) {
+function tapTaskEither<R>(_task: Task<R>, op: (value: Rejectable<R>) => void): Task<R> {
   return tapTaskMaybe<R>(_task, (maybe) => maybe.tap(op));
 }
 
@@ -927,35 +982,35 @@ class TaskClass<R> implements Task<R> {
     }
   }
 
-  tapCanceled(op: () => void) {
+  tapCanceled(op: () => void): Task<R> {
     return tapTaskMaybe<R>(this, (maybe) => maybe.orTap(op));
   }
-  tapRejected(op: (error: any) => void) {
+  tapRejected(op: (error: any) => void): Task<R> {
     return tapTaskEither<R>(this, (either) => either.orTap(op));
   }
-  tap(op: (value: R) => void) {
+  tap(op: (value: R) => void): Task<R> {
     return tapTaskEither<R>(this, (either) => either.tap(op));
   }
 
-  mapCanceled<R2>(op: () => R2) {
+  mapCanceled<R2>(op: () => R2): Task<R | R2> {
     return mapTaskMaybe<R, R | R2>(this, (maybe) => maybe.orMap(() => Either.right(op())));
   }
-  mapRejected<R2>(op: (error: any) => R2) {
+  mapRejected<R2>(op: (error: any) => R2): Task<R | R2> {
     return mapTaskEither<R, R | R2>(this, (either) => either.orMap(op));
   }
-  map<R2>(op: (value: R) => R2) {
+  map<R2>(op: (value: R) => R2): Task<R2> {
     return mapTaskEither<R, R2>(this, (either) => either.map(op));
   }
 
-  chainCanceled<R2>(op: () => Task<R2>) {
+  chainCanceled<R2>(op: () => Task<R2>): Task<R | R2> {
     const mapEither = (either: Rejectable<R>) => either.map(Task.resolved).orMap<Task<R>>(Task.rejected).right;
 
     return chainTaskMaybe<R, R | R2>(this, (maybe) => maybe.map(mapEither).orMap(op).just);
   }
-  chainRejected<R2>(op: (error: any) => Task<R2>) {
+  chainRejected<R2>(op: (error: any) => Task<R2>): Task<R | R2>  {
     return chainTaskEither<R, R | R2>(this, (either) => either.map(Task.resolved).orMap(op).right);
   }
-  chain<R2>(op: (value: R) => Task<R2>) {
+  chain<R2>(op: (value: R) => Task<R2>): Task<R2> {
     return chainTaskEither<R, R2>(this, (either) => either.map(op).orMap<Task<R2>>(Task.rejected).right);
   }
 
@@ -995,7 +1050,7 @@ class TaskClass<R> implements Task<R> {
     })(this);
   }
 
-  matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }) {
+  matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }): Task<R> {
     return tapTaskMaybe(this, (maybe) => {
       return maybe.matchTap({
         just: (either) => {
@@ -1009,7 +1064,7 @@ class TaskClass<R> implements Task<R> {
     });
   }
 
-  matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }) {
+  matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }): Task<R2 | R3 | R4> {
     return mapTaskMaybe(this, (maybe) => {
       return Maybe.just(maybe.match<Right<R2 | R3 | R4, any>>({
         just: (either) => {
@@ -1023,7 +1078,7 @@ class TaskClass<R> implements Task<R> {
     });
   }
 
-  matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }) {
+  matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 | R3 | R4> {
     return chainTaskMaybe(this, (maybe) => {
       return maybe.match<Task<R2 | R3 | R4>>({
         just: (either) => {
@@ -1037,3 +1092,9 @@ class TaskClass<R> implements Task<R> {
     });
   }
 }
+
+function reportError(error: unknown): void {
+  if (typeof globalThis.reportError === 'function') {
+    globalThis.reportError(error);
+  }
+}