feat(cancellation): allow fork to chain so cancel can be called after

Author: tdreyno

docs/task-instance.md

@@ -2,6 +2,28 @@
 
 The `Task` class is the core of this library. Below are all the methods that can be called on a task. To create a new task, refer to [Creating Tasks](docs/task-static.md).
 
+## cancel
+
+Cancels a task, meaning it will never complete.
+
+{% tabs %}
+{% tab title="Usage" %}
+
+```typescript
+const task = Task.of(5).cancel();
+```
+
+{% endtab %}
+
+{% tab title="Type Definition" %}
+
+```typescript
+type cancel = () => void;
+```
+
+{% endtab %}
+{% endtabs %}
+
 ## map
 
 Given a task, when it has _succeeded_, pass the value through a mapping function.

src/Task/Task.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-explicit-any, @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-misused-promises, @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-explicit-any, @typescript-eslint/no-use-before-define */
 import { constant, identity, range } from "../util";
 
 export type Reject<E> = (error: E) => void;
@@ -37,27 +37,27 @@ export class Task<E, S> implements PromiseLike<S> {
   public static flatten = flatten;
 
   public isCanceled = false;
-  public fork: Fork<E, S>;
+  constructor(private computation: Fork<E, S>) {}
 
-  constructor(computation: Fork<E, S>) {
-    this.fork = (reject: Reject<E>, resolve: Resolve<S>) => {
-      if (this.isCanceled) {
-        return;
-      }
+  fork(reject: Reject<E>, resolve: Resolve<S>) {
+    if (this.isCanceled) {
+      return this;
+    }
 
-      computation(
-        err => {
-          if (!this.isCanceled) {
-            reject(err);
-          }
-        },
-        value => {
-          if (!this.isCanceled) {
-            resolve(value);
-          }
+    this.computation(
+      err => {
+        if (!this.isCanceled) {
+          reject(err);
         }
-      );
-    };
+      },
+      value => {
+        if (!this.isCanceled) {
+          resolve(value);
+        }
+      }
+    );
+
+    return this;
   }
 
   cancel() {
@@ -313,7 +313,7 @@ export function fork<E, S>(
   reject: Reject<E>,
   resolve: Resolve<S>,
   task: Task<E, S>
-): void {
+): Task<E, S> {
   return task.fork(reject, resolve);
 }
 

src/Task/__tests__/cancellation.spec.ts

@@ -8,14 +8,14 @@ describe("cancellation", () => {
     const resolve = jest.fn();
     const reject = jest.fn();
 
-    const task = succeedIn(1000, SUCCESS_RESULT);
-    task.cancel();
-    task.fork(reject, resolve);
+    succeedIn(1000, SUCCESS_RESULT)
+      .fork(reject, resolve)
+      .cancel();
+
+    jest.runAllTimers();
 
     expect(resolve).not.toBeCalled();
     expect(reject).not.toBeCalled();
-
-    jest.runAllTimers();
   });
 
   test("should be able to cancel a failed task", () => {
@@ -24,13 +24,13 @@ describe("cancellation", () => {
     const resolve = jest.fn();
     const reject = jest.fn();
 
-    const task = failIn(1000, ERROR_RESULT);
-    task.cancel();
-    task.fork(reject, resolve);
+    failIn(1000, ERROR_RESULT)
+      .fork(reject, resolve)
+      .cancel();
+
+    jest.runAllTimers();
 
     expect(resolve).not.toBeCalled();
     expect(reject).not.toBeCalled();
-
-    jest.runAllTimers();
   });
 });