wip

src/concurrency/locks/lockable.spec.ts

@@ -0,0 +1,3 @@
+describe('ResourcePool lock', () => {
+  it.skip('');
+});

src/concurrency/locks/lockable.ts

@@ -1,14 +1,11 @@
+import { ResourcePool } from '../resource-pool';
+
 export class LockableError extends Error {
   static A = class L2 extends LockableError {};
 }
 
-interface AutoClosable {
-  close(): void;
-  [Symbol.dispose](): void;
-}
-
-export abstract class Mutex<Resource extends object | true> {
-  abstract lock(): AutoClosable;
-  abstract unlock(): void;
-  abstract tryLock(): boolean;
+export interface Lease<T> {
+  value: T;
+  // close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
 }

src/concurrency/resource-pool.ts

@@ -5,6 +5,8 @@
  * - NOT supported: replace / refresh / timeout of tasks
  */
 import { wait } from './timing';
+import { Lease } from './locks/lockable';
+import { lazyThenable } from './lazy-thenable';
 
 export class ResourcePool<T> {
   // can be used as a mutex
@@ -38,16 +40,11 @@ export class ResourcePool<T> {
   }
 
   async use<R>(task: (res: T) => R): Promise<Awaited<R>> {
-    const r = await this.borrow();
-    try {
-      return await task(r);
-    } finally {
-      this.resources.push(r);
-      this.balance();
-    }
+    await using lease = await this.borrow();
+    return await task(lease.value);
   }
 
-  tryUse<R>(task: (res: T | null) => R): R | Promise<R> {
+  tryUse<R>(task: (res: T | null) => R): R | Promise<Awaited<R>> {
     if (/** some resource is immediately available */ this.freeCount > 0) {
       return this.use(task);
     } else {
@@ -88,13 +85,33 @@ export class ResourcePool<T> {
     }
   }
 
-  private borrow(): Promise<T> {
+  async borrow(timeout?: number): Promise<Lease<T>> {
+    const v = await this._borrow();
+
+    const _return = lazyThenable(async () => {
+      this._return(v);
+    });
+
+    return {
+      value: v,
+      async [Symbol.asyncDispose]() {
+        await _return;
+      },
+    };
+  }
+
+  private _borrow(): Promise<T> {
     return new Promise<T>((f) => {
       this.consumers.push(f);
       this.balance();
     });
   }
 
+  private _return(value: T): void {
+    this.resources.push(value);
+    this.balance();
+  }
+
   private balance(): void {
     while (this.resources.length && this.consumers.length) {
       const r = this.resources.shift()!;