t-tasks 1.2.1 → 2.1.0

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,13 @@ 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;
+
   /**
    * Return underlying promise in order to await result
    *
@@ -186,16 +195,19 @@ 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: () => void;
+  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) => void;
+  reject: (error: any) => boolean;
 
   /**
    * Wrap task to singleton generator
@@ -242,7 +254,7 @@ export namespace Task {
    * @note low-level primitive for creating custom tasks, not intended for general use
    */
   export function create<R>(invoke: TaskInvoke<R>, cancel: TaskCancel): Task<R> {
-    return new TaskClass<R>(invoke, cancel);
+    return new TaskClass<R>({ resolved: false, invoke, cancel });
   }
 
   /**
@@ -252,8 +264,8 @@ export namespace Task {
    * @param value value to be returned upon awaiting
    * @returns task resolving to specified value
    */
-  export function resolved<R>(value: R) {
-    return Task.create<R>(Promise.resolve(Maybe.just(Either.right(value))), () => void undefined);
+  export function resolved<R>(value: R): Task<R> {
+    return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.right(value)) });
   }
 
   /**
@@ -261,20 +273,20 @@ 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) {
-    return Task.create<R>(Promise.resolve(Maybe.just(Either.left(error))), () => void undefined);
+  export function rejected<R>(error: any): Task<R> {
+    return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.left(error)) });
   }
 
   /**
    * 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>() {
-    return Task.create<R>(Promise.resolve(Maybe.nothing()), () => void undefined);
+  export function canceled<R>(): Task<R> {
+    return new TaskClass<R>({ resolved: true, result: Maybe.nothing() });
   }
 
   /**
@@ -294,19 +306,16 @@ export namespace Task {
    * ```
    */
   export function fromPromise<R>(promise: PromiseLike<R>): Task<R> {
-    const [resolve, setResolve] = resolver<Cancelable<R>>();
+    const cell = settleCell<Cancelable<R>>();
 
-    return Task.create(
-      new Promise<Cancelable<R>>((_resolve) => {
-        setResolve(_resolve);
+    const cancel: TaskCancel = (error: Maybe<any>) => cell.resolve(error.map(Either.left));
+    
+    promise
+      .then(Either.right, Either.left)
+      .then(Maybe.just)
+      .then(cell.resolve);
 
-        promise
-          .then(Either.right, Either.left)
-          .then(Maybe.just)
-          .then(resolve);
-      }),
-      (error: Maybe<any>) => resolve(error.map(Either.left)),
-    );
+    return Task.create(cell.promise, cancel);
   }
 
   /**
@@ -333,24 +342,120 @@ export namespace Task {
    * ```
    */
   export function fromFunction<R>(producer: () => R, cancelRef: { cancel: TaskCancel }): Task<R> {
-    const [resolve, setResolve] = resolver<Cancelable<R>>();
+    const cell = settleCell<Cancelable<R>>();
 
-    const cancel = (error: Maybe<any>) => resolve(error.map(Either.left));
+    const cancel: TaskCancel = (error: Maybe<any>) => cell.resolve(error.map(Either.left));
 
     cancelRef.cancel = cancel;
 
-    return Task.create(
-      new Promise<Cancelable<R>>((_resolve) => {
-        setResolve(_resolve);
+    try {
+      cell.resolve(Maybe.just(Either.right(producer())));
+    } catch (e) {
+      cell.resolve(Maybe.just(Either.left(e)));
+    }
+
+    return Task.create(cell.promise, cancel);
+  }
+
+  /**
+   * Generic callback task
+   *
+   * 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 onCancel cancelation function intended for stopping task execution
+   * @returns task resolving to success value
+   *
+   * @example
+   * ```typescript
+   * export function timeout(delay: number) {
+   *   return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);
+   * }
+   * ```
+   */
+  export function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void, cancel: () => void) => H, onCancel: (handler: H) => void): Task<R> {
+    const cell = settleCell<Cancelable<R>>();
+
+    let handler: { value: H } | null = null;
+
+    const cancel: TaskCancel = (error: Maybe<any>) => {
+      const wasPending = cell.resolve(error.map(Either.left));
+      if (wasPending && handler) {
+        onCancel(handler.value);
+      }
+      return wasPending;
+    }
+
+    try {
+      const value = create(
+        (r) => cell.resolve(Maybe.just(Either.right(r))),
+        (e) => cell.resolve(Maybe.just(Either.left(e))),
+        () => cancel(Maybe.nothing()),
+      );
+
+      handler = { value };
+
+      const result = cell.settled();
+      if (result && !result.value.match({ just: (v) => v.isRight(), nothing: () => false })) {
+        onCancel(value);
+      }
+    } catch (e) {
+      cell.resolve(Maybe.just(Either.left(e)));
+    }
+
+    return Task.create(cell.promise, cancel);
+  }
+
+  /**
+   * Lift an async operation that accepts an AbortSignal into a Task.
+   *
+   * Creates an internal AbortController and passes its signal to `producer`.
+   * If the resulting task is canceled or rejected externally, `controller.abort()`
+   * is called automatically.
+   *
+   * @template R returned task resolve type
+   * @param producer factory function receiving an AbortSignal
+   * @returns task wrapping the operation
+   *
+   * @example
+   * ```typescript
+   * const fetchUser = (id: string) =>
+   *   Task.fromAbortSignal((signal) =>
+   *     fetch(`/api/users/${id}`, { signal }).then((res) => res.json())
+   *   );
+   * ```
+   */
+  export function fromAbortSignal<R>(
+    producer: (signal: AbortSignal) => PromiseLike<R>
+  ): Task<R> {
+    const cell = settleCell<Cancelable<R>>();
+    const controller = new AbortController();
+
+    const cancel: TaskCancel = (error: Maybe<any>) => {
+      const wasPending = cell.resolve(error.map(Either.left));
+      if (wasPending) {
+        controller.abort(error.match({ just: (err) => err, nothing: () => undefined }));
+      }
+      return wasPending;
+    };
 
-        try {
-          resolve(Maybe.just(Either.right(producer())));
-        } catch (e) {
-          resolve(Maybe.just(Either.left(e)));
+    try {
+      producer(controller.signal).then((value) => {
+        cell.resolve(Maybe.just(Either.right(value)));
+      }, (error) => {
+        if (controller.signal.aborted && (error?.name === 'AbortError' || (typeof DOMException !== 'undefined' && error instanceof DOMException && error.name === 'AbortError'))) {
+          cell.resolve(Maybe.nothing());
+        } else {
+          cell.resolve(Maybe.just(Either.left(error)));
         }
-      }),
-      cancel,
-    );
+      });
+    } catch (e) {
+      cell.resolve(Maybe.just(Either.left(e)));
+    }
+
+    return Task.create(cell.promise, cancel);
   }
 
   /**
@@ -367,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();
@@ -407,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
@@ -431,21 +536,50 @@ export namespace Task {
    * ```
    */
   export function generate<T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<[], T, TT, R>): Task<R> {
-    const generator = taskGeneratorFunction();
-
-    const sequentor = (next: IteratorResult<TT, R>): Task<R> => {
-      return next.done ? (
-        Task.resolved(next.value)
-      ) : (
-        next.value.matchChain<R>({
-          resolved: (value) => sequentor(generator.next(value)),
-          rejected: (error) => sequentor(generator.throw(error)),
-          canceled: Task.canceled,
-        })
-      );
+    const generator: TaskGenerator<T, TT, R> = taskGeneratorFunction();
+    const cell = settleCell<Cancelable<R>>();
+
+    let current: { task: Task<T>; error: Maybe<any> | null } | null = null;
+
+    const sequentor = (invoke: () => IteratorResult<TT, R>, override?: Cancelable<R>) => {
+      try {
+        const next = invoke();
+
+        if (next.done) {
+          cell.resolve(override ?? current?.error?.map(Either.left) ?? Maybe.just(Either.right(next.value)));
+          current = null;
+          return;
+        }
+
+        current = {
+          task: next.value,
+          error: null,
+        };
+
+        next.value._invoke((maybe) => maybe.matchTap({
+          just: (either) => either.matchTap({
+            right: (value) => sequentor(() => generator.next(value), override),
+            left: (error) => sequentor(() => generator.throw(error), override),
+          }),
+          nothing: () => sequentor(() => generator.return(undefined as R), Maybe.nothing()),
+        }))
+      } catch (error) {
+        cell.resolve(override ?? Maybe.just(Either.left(error)));
+        current = null;
+      }
     };
 
-    return Task.resolved(undefined).chain(() => sequentor(generator.next()));
+    sequentor(() => generator.next());
+
+    return Task.create(cell.promise, (error) => {
+      if (cell.settled() || !current) {
+        return false;
+      }
+
+      current.error = error;
+
+      return current.task._cancel(error);
+    });
   }
 
   /**
@@ -453,16 +587,15 @@ 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(function* () {
-      return yield* taskGeneratorFunction(...args);
-    });
+    return (...args: A) => generate(() => taskGeneratorFunction(...args));
   }
 
   /**
@@ -483,51 +616,13 @@ export namespace Task {
    * ```
    */
   export function timeout(delay: number) {
-    return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);
-  }
-
-  /**
-   * Generic callback task
-   *
-   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction
-   *
-   * @param create task body with success and error callbacks
-   * @param cancel cancelation function intended for stopping task execution
-   * @returns task resolving to success value
-   *
-   * @example
-   * ```typescript
-   * export function timeout(delay: number) {
-   *   return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);
-   * }
-   * ```
-   */
-  export function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void, cancel: () => void) => H, onCancel: (handler: H) => void): Task<R> {
-    let handler: H;
-
-    const [resolve, setResolve] = resolver<Cancelable<R>>();
-
-    return Task.create(
-      new Promise<Cancelable<R>>((_resolve) => {
-        setResolve(_resolve);
-
-        handler = create(
-          (r) => resolve(Maybe.just(Either.right(r))),
-          (e) => resolve(Maybe.just(Either.left(e))),
-          () => resolve(Maybe.nothing())
-        );
-      }),
-      (error: Maybe<any>) => {
-        resolve(error.map(Either.left));
-
-        onCancel(handler);
-      },
-    );
+    return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(resolve, delay), clearTimeout);
   }
 
   /**
    * 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
    */
@@ -550,47 +645,38 @@ 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 [resolve, setResolve] = resolver<Cancelable<T[]>>();
-
     const taskArray = Array.from(tasks);
-
-    const cancel = (error: Maybe<any>) => taskArray.forEach((task) => task._cancel(error));
-
-    const list = taskArray.map<Maybe<T>>(Maybe.nothing);
-
-    const resolved = (value: T, i: number) => {
-      list[i] = Maybe.just(value);
-
-      if (Maybe.everyJust(list)) {
-        resolve(Maybe.just(Either.right(list.map(Just.just))));
-      }
-    };
-    const rejected = (error: Maybe<any>) => {
-      resolve(error.map(Either.left));
-      cancel(error);
-    };
-
-    return Task.create(
-      new Promise<Cancelable<T[]>>((_resolve) => {
-        setResolve(_resolve);
-
-        if (taskArray.length < 1) {
-          return resolve(Maybe.just(Either.right([])));
-        }
-
-        taskArray.map((task, i) => {
-          return task.matchTap({
-            resolved: (value) => resolved(value, i),
-            rejected: (error) => rejected(Maybe.just(error)),
-            canceled: () => rejected(Maybe.nothing()),
-          });
+    if (taskArray.length === 0) {
+      return Task.resolved([]);
+    }
+
+    return Task.fromCallback<Task<T>[], T[]>((resolve, reject, cancel) => {
+      const results: T[] = new Array(taskArray.length);
+      let remaining = taskArray.length;
+
+      taskArray.forEach((task, i) => {
+        task.matchTap({
+          resolved: (value) => {
+            results[i] = value;
+            remaining--;
+            if (remaining === 0) resolve(results);
+          },
+          rejected: (error) => {
+            reject(error);
+            taskArray.forEach((t) => t.cancel());
+          },
+          canceled: () => {
+            cancel();
+            taskArray.forEach((t) => t.cancel());
+          },
         });
-      }),
-      cancel,
-    );
+      });
+
+      return taskArray;
+    }, (subtasks) => subtasks.forEach((t) => t.cancel()));
   }
 
   /**
@@ -605,47 +691,43 @@ 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 [resolve, setResolve] = resolver<Cancelable<T>>();
+    const cell = settleCell<Cancelable<T>>();
 
     const taskArray = Array.from(tasks);
 
-    const cancel = (error: Maybe<any>) => taskArray.forEach((task) => task._cancel(error));
+    if (taskArray.length < 1) {
+      return Task.canceled();
+    }
 
-    const list = taskArray.map<Maybe<any>>(Maybe.nothing);
+    const cancel = (error: Maybe<any>) => taskArray.map((task) => task._cancel(error)).every((r) => r);
+
+    const list = taskArray.map<Maybe<any>>(() => Maybe.nothing());
 
     const resolved = (value: Maybe<T>) => {
-      resolve(value.map(Either.right));
+      cell.resolve(value.map(Either.right));
       cancel(Maybe.nothing());
     };
+
     const rejected = (error: any, i: number) => {
       list[i] = Maybe.just(error);
 
       if (Maybe.everyJust(list)) {
-        resolve(Maybe.just(Either.left(list.map(Just.just))));
+        cell.resolve(Maybe.just(Either.left(list.map((v) => Just.just(v)))));
       }
     };
 
-    return Task.create(
-      new Promise<Cancelable<T>>((_resolve) => {
-        setResolve(_resolve);
-
-        if (taskArray.length < 1) {
-          return resolve(Maybe.nothing());
-        }
+    taskArray.map((task, i) => {
+      return task.matchTap({
+        resolved: (value) => resolved(Maybe.just(value)),
+        rejected: (error) => rejected(error, i),
+        canceled: () => resolved(Maybe.nothing()),
+      });
+    });
 
-        taskArray.map((task, i) => {
-          return task.matchTap({
-            resolved: (value) => resolved(Maybe.just(value)),
-            rejected: (error) => rejected(error, i),
-            canceled: () => resolved(Maybe.nothing()),
-          });
-        });
-      }),
-      cancel,
-    );
+    return Task.create(cell.promise, cancel);
   }
 
   /**
@@ -654,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
@@ -668,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);
@@ -682,152 +767,281 @@ export namespace Task {
 /// --------------------------------------------------------------------------------------
 
 type TaskInvoke<R> = Promise<Cancelable<R>>;
-type TaskCancel = (error: Maybe<any>) => void;
+type TaskCancel = (error: Maybe<any>) => boolean;
 
 /**
  * @hidden
  */
 interface TaskBase<R> {
-  /**
-   * @hidden
-   */
-  readonly _invoke: TaskInvoke<R>;
-  /**
-   * @hidden
-   */
-  readonly _cancel: TaskCancel;
+  _invoke(op: (result: Cancelable<R>) => void): void;
+  _cancel(error: Maybe<any>): boolean;
 }
 
-const resolver = <T>() => {
-  const stub: (t: T) => void = () => void undefined;
-
-  let globalResolve = stub;
+/**
+ * One-shot settlement cell.
+ *
+ * The Promise is created internally, so there is no unarmed window: `resolve`
+ * before or after construction always owns the result (first writer wins).
+ * Later `resolve` calls are ignored. Reentrant `resolve` from the sink is ignored.
+ *
+ * `settled` is for skipping continuations; it does not cancel children by itself.
+ * After creating a child, if `settled` is already true, cancel that child with
+ * the stored value. Bind `_cancel` to the child only after that check.
+ */
+type SettleCell<T> = {
+  readonly promise: Promise<T>;
+  readonly resolve: (value: T) => boolean;
+  readonly settled: () => { value: T } | null;
+};
 
-  const resolve = (value: T) => {
-    const r = globalResolve;
+const stub = () => void undefined;
 
-    globalResolve = stub;
+const settleCell = <T>(): SettleCell<T> => {
+  let sink: (value: T) => void = stub;
+  let settled: { value: T } | null = null;
 
-    r(value);
-  };
+  const promise = new Promise<T>((resolve) => {
+    sink = resolve;
+  });
 
-  const setResolve = (value: typeof resolve) => {
-    globalResolve = value;
-  };
+  const resolve = (next: T) => {
+    if (settled) {
+      return false;
+    }
 
-  return [resolve, setResolve] as [typeof resolve, typeof setResolve];
-};
+    settled = { value: next };
 
-function chainTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Task<R2>) {
-  const globalCancel = { cancel: _task._cancel };
+    sink(next);
 
-  return Task.create(
-    _task._invoke.then(async (result) => {
-      // Tecnically it's not possible to throw here anymore as op is lifted into task now, but just in case
-      try {
-        const { _invoke: invoke2, _cancel: cancel2 } = Task.fromFunction(() => op(result), globalCancel);
+    return true;
+  };
 
-        globalCancel.cancel = cancel2;
+  return {
+    promise,
+    resolve,
+    settled: () => settled,
+  };
+};
 
-        const produced = await invoke2;
+function chainTaskMaybe<R, R2>(parent: Task<R>, op: (value: Cancelable<R>) => Task<R2>): Task<R2> {
+  const cell = settleCell<Cancelable<R2>>();
+
+  let state:
+    | { phase: 'parent' }
+    | { phase: 'transform', error: Maybe<any> | null }
+    | { phase: 'child', cancel: TaskCancel }
+    | { phase: 'closed' } = { phase: 'parent' };
+
+  parent._invoke((result) => {
+    state = { phase: 'transform', error: null }
+
+    let child: Task<R2> | null = null;
+    try {
+      child = op(result);
+    } catch (e) {
+      cell.resolve(Maybe.just(Either.left(e)));
+      state = { phase: 'closed' };
+      return;
+    }
+
+    const transformError = state.phase === 'transform' ? state.error : null;
+
+    state = { phase: 'child', cancel: (error) => child._cancel(error) };
+
+    if (transformError) {
+      cell.resolve(transformError.map(Either.left));
+      state = { phase: 'closed' };
+      child._cancel(transformError);
+      return;
+    }
+
+    return child._invoke((value) => {
+      cell.resolve(value);
+      state = { phase: 'closed' };
+    });
+  });
 
-        if (produced.isNothing()) {
-          return Maybe.nothing();
-        }
+  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 if (state.phase === 'child') {
+      return state.cancel(error);
+    } else {
+      return false;
+    }
+  });
+}
 
-        if (produced.just.isLeft()) {
-          return Maybe.just(Either.left(produced.just.left));
-        }
+function mapTaskMaybe<R, R2>(parent: Task<R>, op: (value: Cancelable<R>) => Cancelable<R2>): Task<R2> {
+  const cell = settleCell<Cancelable<R2>>();
+
+  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' };
+  });
 
-        const { _invoke: invoke3, _cancel: cancel3 } = produced.just.right;
+  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;
+    }
+  });
+}
 
-        globalCancel.cancel = cancel3;
+function tapTaskMaybe<R>(parent: Task<R>, op: (value: Cancelable<R>) => void): Task<R> {
+  parent._invoke((result) => {
+    try {
+      op(result);
+    } catch (e) {
+      reportError(e);
+    }
+  });
 
-        return invoke3;
-      } catch (e) {
-        return Maybe.just(Either.left(e));
-      }
-    }),
-    (error: Maybe<any>) => globalCancel.cancel(error),
-  );
+  return parent;
 }
 
-function chainTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Task<R2>) {
+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);
 }
 
-function mapTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Cancelable<R2>) {
-  return chainTaskMaybe<R, R2>(_task, (maybe) => {
-    return op(maybe).matchMap<Task<R2>>({
-      just: (either) =>
-        either.matchMap<Task<R2>>({
-          right: Task.resolved,
-          left: Task.rejected,
-        }).right,
-      nothing: Task.canceled,
-    }).just;
-  });
-}
-
-function mapTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Rejectable<R2>) {
+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 tapTaskMaybe<R>(_task: TaskBase<R>, op: (value: Cancelable<R>) => void) {
-  return mapTaskMaybe<R, R>(_task, (value) => {
-    op(value);
-
-    return value;
-  });
-}
-
-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));
 }
 
+type SyncState<R> =
+  | { resolved: false; invoke: TaskInvoke<R>; cancel: TaskCancel }
+  | { resolved: true; result: Cancelable<R> }
+
 class TaskClass<R> implements Task<R> {
-  constructor(readonly _invoke: TaskInvoke<R>, readonly _cancel: TaskCancel) {}
+  constructor(private _state: SyncState<R>) {
+    if (!this._state.resolved) {
+      this._state.invoke = this._state.invoke.then((result) => {
+        if (!this._state.resolved) {
+          this._state = { resolved: true, result }
+        }
+        return result;
+      });
+    }
+  }
 
-  tapCanceled(op: () => void) {
+  _invoke(op: (result: Cancelable<R>) => void) {
+    if (this._state.resolved) {
+      return op(this._state.result);
+    } else {
+      return this._state.invoke.then(op);
+    }
+  }
+
+  _cancel(error: Maybe<any>) {
+    if (this._state.resolved) {
+      return false
+    } else {
+      return this._state.cancel(error);
+    }
+  }
+
+  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);
   }
 
+  resolved() {
+    if (this._state.resolved) {
+      return this._state.result;
+    } else {
+      return null;
+    }
+  }
+
   resolve() {
-    return this._invoke;
+    if (this._state.resolved) {
+      return Promise.resolve(this._state.result);
+    } else {
+      return this._state.invoke;
+    }
   }
   cancel() {
-    return this._cancel(Maybe.nothing());
+    if (this._state.resolved) {
+      return false;
+    } else {
+      return this._state.cancel(Maybe.nothing());
+    }
   }
   reject(error: any) {
-    return this._cancel(Maybe.just(error));
+    if (this._state.resolved) {
+      return false;
+    } else {
+      return this._state.cancel(Maybe.just(error));
+    }
   }
 
   generator() {
@@ -836,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) => {
@@ -850,31 +1064,37 @@ 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.matchMap<Right<R2 | R3 | R4, any>>({
+      return Maybe.just(maybe.match<Right<R2 | R3 | R4, any>>({
         just: (either) => {
-          return either.matchMap({
+          return Either.right(either.match({
             right: op.resolved,
             left: op.rejected,
-          });
+          }));
         },
         nothing: () => Either.right(op.canceled()),
-      });
+      }));
     });
   }
 
-  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.matchMap<Task<R2 | R3 | R4>>({
+      return maybe.match<Task<R2 | R3 | R4>>({
         just: (either) => {
-          return either.matchMap<Task<R2 | R3>>({
+          return either.match<Task<R2 | R3>>({
             right: op.resolved,
             left: op.rejected,
-          }).right;
+          });
         },
         nothing: op.canceled,
-      }).just;
+      });
     });
   }
 }
+
+function reportError(error: unknown): void {
+  if (typeof globalThis.reportError === 'function') {
+    globalThis.reportError(error);
+  }
+}