Add support for async disposable

lib/task.ts

@@ -1,3 +1,4 @@
+/// <reference lib="esnext" />
 // deno-lint-ignore-file no-unsafe-finally
 import { DelimiterContext, ErrorContext } from "./delimiter.ts";
 import { createCoroutine } from "./coroutine.ts";
@@ -74,6 +75,12 @@ export function createTask<T>(options: TaskOptions<T>): NewTask<T> {
       enumerable: false,
       value: "Task",
     },
+    [Symbol.asyncDispose]: {
+      enumerable: false,
+      value: async function () {
+        return await this.halt();
+      },
+    },
   }) as Task<T>;
 
   let boundary = owner.expect(ErrorContext);

lib/types.ts

@@ -52,7 +52,9 @@ export interface Operation<T> {
  * things, if the operation resolves synchronously, it will continue within the
  * same tick of the run loop.
  */
-export interface Future<T> extends Operation<T>, Promise<T> {}
+export interface Future<T> extends Operation<T>, Promise<T> {
+  [Symbol.dispose](): void;
+}
 
 /**
  * A handle to a concurrently running operation that lets you either use the
@@ -334,8 +336,9 @@ export interface Scope {
  * Analogous to the built in [`Awaited`](https://www.typescriptlang.org/docs/handbook/utility-types.html#awaitedtype) type.
  * `Yielded<Operation<T>> === T`
  */
-export type Yielded<T extends Operation<unknown>> = T extends
-  Operation<infer TYield> ? TYield
+export type Yielded<T extends Operation<unknown>> = T extends Operation<
+  infer TYield
+> ? TYield
   : never;
 
 // low-level private apis.

test/run.test.ts

@@ -13,9 +13,11 @@ import {
 
 describe("run()", () => {
   it("can run an operation", async () => {
-    await expect(run(function* () {
-      return "hello";
-    })).resolves.toEqual("hello");
+    await expect(
+      run(function* () {
+        return "hello";
+      }),
+    ).resolves.toEqual("hello");
   });
 
   it("can compose multiple promises via generator", async () => {
@@ -318,4 +320,45 @@ describe("run()", () => {
     await expect(task).rejects.toHaveProperty("message", "boom!");
     await expect(task.halt()).resolves.toBe(undefined);
   });
+
+  it("can be disposed with 'await using'", async () => {
+    let halted = false;
+
+    let task = run(function* () {
+      try {
+        yield* suspend();
+      } finally {
+        halted = true;
+      }
+    });
+
+    {
+      await using _ = task;
+    }
+
+    expect(halted).toEqual(true);
+  });
+
+  it("should throw when 'halt' is invoked after 'await using'", async () => {
+    let halted = false;
+    let error: Error | undefined;
+
+    let task = run(function* () {
+      try {
+        yield* suspend();
+      } finally {
+        halted = true;
+      }
+    });
+
+    {
+      await using _ = task;
+      _.catch((e) => error = e);
+      await _.halt();
+    }
+
+    expect(error).toBeDefined();
+    expect(error?.message).toEqual("halted");
+    expect(halted).toEqual(true);
+  });
 });