Hey all... had some feedback come up with regards to Explicit Resource Management today that I wanted to surface and get some input on. The question specifically is, "I think explicit resource management is missing a really important feature: The ability to transfer ownership. I need a way to "release" a variable I declared with using, especially to return it." ... essentially treating the ERM/using as similar to an RAII that can be moved away.

function foo() {
  using foo = new Foo();
  using bar = new Bar();
  // I only want foo or bar disposed if they are not returned
  if (someCondition()) return bar; 
  else return foo;
}

Another example to stew on...

function foo() {
  using bar = new MyDisposable();
  if (someCondition()) throw new Error('boom'); // I want bar disposed in this case
  return bar;  // I don't want it disposed in this case
}

function movable(foo) {
  let dispose = foo[Symbol.dispose];
  if (typeof dispose !== 'function') throw new Error('not disposable');
  return {
    resource: foo,
    moved: false,
    [Symbol.dispose]() {
      if (this.moved) return;
      dispose.call(foo);
    },
    move() {
      this.moved = true;
      return foo;
    },
  }
}

// usage:
function makeDisposable() {
  return {
    [Symbol.dispose]() {
      console.log('disposed');
    },
  };
}
{
  using movableFoo = movable(makeDisposable());
  const { resource: foo } = movableFoo;
  console.log('normal exit');
  // disposed
}
{
  using movableFoo = movable(makeDisposable());
  const { resource: foo } = movableFoo;
  movableFoo.move();
  console.log('moved before exit');
  // not disposed
}