FAQ: Why not just add a callback to WeakMap/WeakSet?

[xaviergonz]

What if it was done like this instead?

const weakObjs = new WeakSet([], objectAboutToBeCollected => {
  // here do something with the object right before it is going to be collected,e.g.
  objectAboutToBeCollected.dispose();
  // or if objectAboutToBeCollected is attached to a live object then collection is cancelled,
  // this method will be called again when it is ready to be collected once more
});

same for WeakMap

if listening for an object finalization is no longer needed then it can just be removed from the set / the set can be collected

[xaviergonz]

Real use case, I have a library that returns WASM objects with native memory that needs to be reclaimed, it offers a dispose() method on such objects to do so, but the library user might forget to call it (therefore produce a memory leak)

library side

const wasmObjects = new WeakSet([], obj => obj.dispose());

function gimmeAWasmObject() {
  const wasmObject = createWasmObjectWithDisposer();
  wasmObjects.add(wasmObject);
  return wasmObject;
}

user side

const obj = gimmeAWasmObject();
obj = undefined; // no worries, the callback in the WeakSet will be called and dispose it

[fitzgen]

The finalization callback can't be given the object itself. That would allow the finalizer to either revive the dead object or create memory unsafety, neither of which are permissible.

Broader point: wasm finalization is definitely something that this proposal intends to support :)

[xaviergonz]

What about making it only available for WeakMap and being the value (rather than the key, which is the dead object) the one that is sent to the callback?

const wasmObjects = new WeakMap({}, valueWhichIsTheDisposer => valueWhichIsTheDisposer());

function gimmeAWasmObject() {
  const [wasmObject, disposer] = createWasmObjectWithDisposer();
  wasmObjects.set(wasmObject, disposer);
  return wasmObject;
}

If value keeps the object alive then the callback will never be called.
If the value doesn't keep the object alive (as it should be) then the callback will be called.

[gsathya]

It's not obviously clear that the key will be the target and value will be the holdings. Apart from being similar in terms of dealing with weak objects, WeakMap and FinalizationGroup seem pretty orthogonal in their use cases. It seems better to have separate API for different use cases. Your particular use case would be better solved with a FinalizationGroup rather than a WeakMap.

[bergus]

WeakSet/WeakMap provide ephemerons, not weak references - they cannot be followed. A finalisation callback would be one thing, the more important thing would be to make the collections iterable. And in many cases, you need only a single weak reference, not a collection of them, so this approach misses objective.

[littledan]

Let's add an explanation in the README about why this would not provide a solution. PRs welcome.