Hacker News Reader

> This isn't actually about removing the promise (completion) listener, but the fact that promises are not cancelable in JS.

You've made an interesting point about promise cancellation but it's ultimately orthogonal to the Github issue I was responding to. The case in question was one in which a memory leak was triggered specifically by racing a long lived promise with another promise — not simply the existence of the promise — but specifically racing that promise against another promise with a shorter lifetime. You shouldn't have to cancel that long lived promise in order to resolve the memory leak. The user who created the issue was creating a promise that resolved whenever the SIGINT signal was received. Why should you have to cancel this promise early in order to tame the memory usage (and only while racing it against another promise)?

As the Node contributor discovered the reason is because semantically `Promise.race` operates similarly to this [1]:

  function race<X, Y>(x: PromiseLike<X>, y: PromiseLike<Y>) {
    return new Promise((resolve, reject) => {
      x.then(resolve, reject)
      y.then(resolve, reject)
    })
  }

Assuming `x` is our non-settling promise, he was able to resolve the memory leak by monkey patching `x` and replacing its then method with a no-op which ignores the resolve and reject listeners: `x.then = () => {};`. Now of course, ignoring the listeners is obviously not ideal, and if there was a native mechanism for removing the resolve and reject listeners `Promise.race` would've used it (perhaps using `y.finally()`) which would have solved the memory leak.

[1] https://github.com/nodejs/node/issues/17469#issuecomment-349...

View on HN

#! /usr/bin/env node --max-old-space-size=5 const interruptPromise = new Promise(resolve => process.once('SIGINT', () => resolve('interrupted')) ) async function run() { while (true) { const taskPromise = new Promise(resolve => setImmediate(resolve)) const result = await Promise.race([taskPromise, interruptPromise]) if (result === 'interrupted') break } console.log(`SIGINT`) } run()

const interruptPromiseAndLog = () => interruptPromise() // How do you unsubscribe this one .then(() => console.log('SIGINT')) // ...even if you can easily proxy this one? .then(() => console.log('REALLY SIGINT'))

const interruptPromiseAndLog = async () => { console.log('Waiting for SIGINT') // You have to proxy and somehow propagate unsubscription to this one too... how!? await interruptPromise() console.log('SIGINT') }

const interruptPromiseAndLog = () => { console.log('Waiting for SIGINT') return interruptPromise() // Needs unsubscription forwarded here .then(() => console.log('SIGINT')) }