feat: add IterableWeakSet

Author: wan2land

.vscode/settings.json

@@ -4,5 +4,8 @@
   "deno.unstable": true,
   "editor.formatOnSave": true,
   "editor.defaultFormatter": "denoland.vscode-deno",
-  "cSpell.words": []
+  "cSpell.words": [
+    "iwset",
+    "wset"
+  ]
 }

iterable_weak_set.test.ts

@@ -0,0 +1,162 @@
+import { assert, assertEquals, assertFalse } from "testing/asserts.ts";
+import { IterableWeakSet } from "./iterable_weak_set.ts";
+
+Deno.test("IterableWeakSet, comparison Set, WeakSet", () => {
+  const set = new Set();
+  const wset = new WeakSet();
+  const iwset = new IterableWeakSet();
+
+  assertEquals(set.size, 0);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 0);
+
+  const obj1 = {};
+  const obj2 = {};
+
+  assertEquals(set.add(obj1), set);
+  assertEquals(wset.add(obj1), wset);
+  assertEquals(iwset.add(obj1), iwset);
+
+  assertEquals(set.size, 1);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 1);
+
+  // add the same object again
+  assertEquals(set.add(obj1), set);
+  assertEquals(wset.add(obj1), wset);
+  assertEquals(iwset.add(obj1), iwset);
+
+  assertEquals(set.size, 1);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 1);
+
+  assertEquals(set.add(obj2), set);
+  assertEquals(wset.add(obj2), wset);
+  assertEquals(iwset.add(obj2), iwset);
+
+  assertEquals(set.size, 2);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 2);
+
+  assert(set.has(obj1));
+  assert(wset.has(obj1));
+  assert(iwset.has(obj1));
+
+  // delete the object
+  assert(set.delete(obj1));
+  assert(wset.delete(obj1));
+  assert(iwset.delete(obj1));
+
+  assertEquals(set.size, 1);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 1);
+
+  assertFalse(set.delete(obj1));
+  assertFalse(wset.delete(obj1));
+  assertFalse(iwset.delete(obj1));
+
+  assertEquals(set.size, 1);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 1);
+
+  assertFalse(set.has(obj1));
+  assertFalse(wset.has(obj1));
+  assertFalse(iwset.has(obj1));
+
+  assertFalse(set.clear());
+  // assertFalse(wset.clear());
+  assertFalse(iwset.clear());
+
+  assertEquals(set.size, 0);
+  // assertEquals(wset.size, 0);
+  assertEquals(iwset.size, 0);
+
+  assertEquals(set.toString(), "[object Set]");
+  assertEquals(wset.toString(), "[object WeakSet]");
+  assertEquals(iwset.toString(), "[object IterableWeakSet]");
+});
+
+Deno.test("IterableWeakSet, iterable", () => {
+  const objs = [{}, {}, {}];
+
+  const sets = [
+    new Set(objs),
+    new IterableWeakSet(objs),
+  ];
+
+  for (const set of sets) {
+    assertEquals(set.size, 3);
+
+    {
+      let i = 0;
+      set.forEach(function (this: unknown, v1, v2, s) {
+        assert(this === undefined);
+        assert(v1 === objs[i]);
+        assert(v2 === objs[i]);
+        assert(s === set);
+        i++;
+      });
+      assertFalse(i === 0);
+    }
+    {
+      let i = 0;
+      set.forEach(function (this: unknown, v1, v2, s) {
+        assert(this === ":D");
+        assert(v1 === objs[i]);
+        assert(v2 === objs[i]);
+        assert(s === set);
+        i++;
+      }, ":D");
+      assertFalse(i === 0);
+    }
+    {
+      let i = 0;
+      for (const obj of set) {
+        assert(obj === objs[i++]);
+      }
+      assertFalse(i === 0);
+    }
+    {
+      let i = 0;
+      for (const obj of set.keys()) {
+        assert(obj === objs[i++]);
+      }
+      assertFalse(i === 0);
+    }
+    {
+      let i = 0;
+      for (const obj of set.values()) {
+        assert(obj === objs[i++]);
+      }
+      assertFalse(i === 0);
+    }
+    {
+      let i = 0;
+      for (const tuple of set.entries()) {
+        assert(tuple[0] === objs[i]);
+        assert(tuple[1] === objs[i++]);
+      }
+      assertFalse(i === 0);
+    }
+  }
+});
+
+Deno.test("IterableWeakSet, garbage collect", async () => {
+  let removedCount = 0;
+  let insertedCount = 0;
+  const register = new FinalizationRegistry(() => {
+    removedCount++;
+  });
+
+  const set = new IterableWeakSet();
+  for (let i = 0; removedCount < 100; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 16));
+    const data = {};
+    set.add(data);
+    register.register(data, i);
+    insertedCount++;
+  }
+
+  assertEquals(insertedCount - removedCount, set.size);
+  assertEquals([...set].length, set.size);
+});

iterable_weak_set.ts

@@ -0,0 +1,87 @@
+// deno-lint-ignore-file ban-types
+
+export class IterableWeakSet<T extends object> implements WeakSet<T>, Set<T> {
+  #weakMap = new WeakMap<T, WeakRef<T>>();
+  #set = new Set<WeakRef<T>>();
+  #registry = new FinalizationRegistry<WeakRef<T>>(
+    this.#set.delete.bind(this.#set),
+  );
+
+  constructor(values?: readonly T[] | null);
+  constructor(iterable: Iterable<T>);
+  constructor(iterable: Iterable<T> | readonly T[] | null = null) {
+    for (const value of iterable ?? []) {
+      this.add(value);
+    }
+  }
+
+  get size(): number {
+    return this.#set.size;
+  }
+
+  add(value: T): this {
+    if (this.has(value)) {
+      return this;
+    }
+    const ref = new WeakRef(value);
+    this.#weakMap.set(value, ref);
+    this.#set.add(ref);
+    this.#registry.register(value, ref, ref);
+    return this;
+  }
+
+  clear(): void {
+    for (const value of this.#set) {
+      this.delete(value.deref()!);
+    }
+  }
+
+  delete(value: T): boolean {
+    const ref = this.#weakMap.get(value);
+    if (ref) {
+      this.#set.delete(ref);
+      this.#weakMap.delete(value);
+      this.#registry.unregister(ref);
+      return true;
+    }
+    return false;
+  }
+
+  has(value: T): boolean {
+    return this.#weakMap.has(value);
+  }
+
+  forEach(
+    callbackfn: (value: T, value2: T, set: Set<T>) => void,
+    thisArg?: unknown,
+  ): void {
+    for (const tuple of this.entries()) {
+      callbackfn.call(thisArg, tuple[0], tuple[1], this);
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return "IterableWeakSet";
+  }
+
+  *[Symbol.iterator](): IterableIterator<T> {
+    for (const ref of this.#set) {
+      yield ref.deref()!;
+    }
+  }
+
+  *entries(): IterableIterator<[T, T]> {
+    for (const ref of this.#set) {
+      const value = ref.deref()!;
+      yield [value, value];
+    }
+  }
+
+  keys(): IterableIterator<T> {
+    return this[Symbol.iterator]();
+  }
+
+  values(): IterableIterator<T> {
+    return this[Symbol.iterator]();
+  }
+}

mod.ts

@@ -0,0 +1 @@
+export { IterableWeakSet } from "./iterable_weak_set.ts";