Clean way to keep original variable and destruction at the same time

Question

Is there a cleaner way to do this (with anything that is at least an ES draft and has a babel plugin, i.e., ES6, ES7, etc.):

const { a, b } = result = doSomething();

Where I want to keep the overall result as one singular object, but also destructure it at the same time. It technically works, but result is implicitly declared (with an implicit var), while I'd really like it to also be a const.

I'm currently doing this:

const result = doSomething();
const { a, b } = result;

Which again works, but it's slightly on the verbose side, since I need to repeat this pattern dozens of times.

I'd ideally want something along the lines of:

const { a, b } = const result = doSomething();

But that is obviously an invalid syntax.

Answer 1

One possible way:

const result = doSomething(), 
    { a, b } = result;

You still have to duplicate the name, though. const token isn't quite right-handy. )

Answer 2

Idea 1

Create this helper function:

function use(input, callback) {
    callback(input, input);
}

and use it like:

use(doSomething(), (result, {a, b}) => {
    // Do something with result as a whole, or a and b as destructured properties.
});

For example:

use ({a: "Hello", b: "World", c: "!"}, (result, {a, b}) => {
  console.log(result);
  console.log(a);
  console.log(b);
});

// generates
// {a: "Hello", b: "World", c: "!"}
// Hello
// World

They're not const, but they're scoped, for better or worse!

---

Idea 2

Combine array and object deconstruction. Create this helper function:

const dup = input => [input, input];

And then deconstruct away like so:

const [result, {a, b}] = dup(doSomething());

Now, your result, a, and b are all consts.