I'd like to gauge the feasibility of a new feature, akin to ignored values
in array destructuring
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values>
:

function ignoredArgument (foo,,baz) {
>   return foo+baz;
> }
> console.log(ignoredArgument(1,2,3) === 4);



Which could replace this common idiom, alleviating the need for an unused
variable:

function ignoredArgument (foo,_,baz) {
>   return foo+baz;
> }
> console.log(ignoredArgument(1,2,3) === 4);



Does this feature make sense for a proposal? Am I missing anything?
-- 
—Dan Kaplun • dbkaplun at gmail.com • 216-236-4601
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20160304/9ccd82f5/attachment.html>

I'd like to gauge the feasibility of a new feature, akin to [ignored values
in array destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values):

```js
function ignoredArgument (foo,,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Which could replace this common idiom, alleviating the need for an unused
variable:

```js
function ignoredArgument (foo,_,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Does this feature make sense for a proposal? Am I missing anything?

I'd like to gauge the feasibility of a new feature, akin to [ignored values
in array destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values):

```js
function ignoredArgument (foo,,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Which could replace this common idiom, alleviating the need for an unused
variable:

```js
function ignoredArgument (foo,_,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Does this feature make sense for a proposal? Am I missing anything?

See also: https://github.com/tc39/ecma262/issues/454

I'd like to gauge the feasibility of a new feature, akin to [ignored values
in array destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values):

```js
function ignoredArgument (foo,,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Which could replace this common idiom, alleviating the need for an unused
variable:

```js
function ignoredArgument (foo,_,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Does this feature make sense for a proposal? Am I missing anything?

I'd like to gauge the feasibility of a new feature, akin to [ignored values
in array destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values)
:

```js
function ignoredArgument (foo,,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Which could replace this common idiom, alleviating the need for an unused
variable:

```js
function ignoredArgument (foo,_,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Does this feature make sense for a proposal? Am I missing anything?

I'd like to gauge the feasibility of a new feature, akin to ignored values
in array destructuring
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values>
:

```js
function ignoredArgument (foo,,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Which could replace this common idiom, alleviating the need for an unused
variable:

```js
function ignoredArgument (foo,_,baz) {
  return foo+baz;
}
console.log(ignoredArgument(1,2,3) === 4);
```


Does this feature make sense for a proposal? Am I missing anything?

I'd like to gauge the feasibility of a new feature, akin to ignored values
in array destructuring
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Ignoring_some_returned_values>
:

> function ignoredArgument (foo,,baz) {
>   return foo+baz;
> }
> console.log(ignoredArgument(1,2,3) === 4);



Which could replace this common idiom, alleviating the need for an unused
variable:

> function ignoredArgument (foo,_,baz) {
>   return foo+baz;
> }
> console.log(ignoredArgument(1,2,3) === 4);



Does this feature make sense for a proposal? Am I missing anything?