Ignoring arguments

classic Classic list List threaded Threaded
27 messages Options
12
Reply | Threaded
Open this post in threaded view
|

Ignoring arguments

Cyril Auburtin
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Renki Ivanko
You can already do it like this:

```js
((...[,,foo]) => foo)(1, 2, 3) // -> 3
```


On Sun, May 29, 2016 at 6:53 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Bob Myers
I'm quite sure this syntax is invalid.


On Sun, May 29, 2016 at 9:36 PM, Renki Ivanko <[hidden email]> wrote:
You can already do it like this:

```js
((...[,,foo]) => foo)(1, 2, 3) // -> 3
```


On Sun, May 29, 2016 at 6:53 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Renki Ivanko
It works in V8 at least, so I assumed it's correct.

On Sun, May 29, 2016 at 8:29 PM, Bob Myers <[hidden email]> wrote:
I'm quite sure this syntax is invalid.


On Sun, May 29, 2016 at 9:36 PM, Renki Ivanko <[hidden email]> wrote:
You can already do it like this:

```js
((...[,,foo]) => foo)(1, 2, 3) // -> 3
```


On Sun, May 29, 2016 at 6:53 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Caitlin Potter
In reply to this post by Bob Myers
You might think so, but you'd be wrong. Perfectly valid formal parameters

On May 29, 2016, at 1:29 PM, Bob Myers <[hidden email]> wrote:

I'm quite sure this syntax is invalid.


On Sun, May 29, 2016 at 9:36 PM, Renki Ivanko <[hidden email]> wrote:
You can already do it like this:

```js
((...[,,foo]) => foo)(1, 2, 3) // -> 3
```


On Sun, May 29, 2016 at 6:53 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Caitlin Potter
In reply to this post by Renki Ivanko
It is.



On May 29, 2016, at 1:36 PM, Renki Ivanko <[hidden email]> wrote:

It works in V8 at least, so I assumed it's correct.

On Sun, May 29, 2016 at 8:29 PM, Bob Myers <[hidden email]> wrote:
I'm quite sure this syntax is invalid.


On Sun, May 29, 2016 at 9:36 PM, Renki Ivanko <[hidden email]> wrote:
You can already do it like this:

```js
((...[,,foo]) => foo)(1, 2, 3) // -> 3
```


On Sun, May 29, 2016 at 6:53 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Bob Myers
In reply to this post by Cyril Auburtin
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Logan Smyth
In reply to this post by Renki Ivanko
```
function fn(...[a, b, c, ...rest]){}
```
is mostly no different than
```
function fn(...args){
    let [a, b, c, ...rest] = args;
}
```

This wasn't officially allowed in ES2015, where only an Identifier was allowed as a rest param target in arguments, but the behavior has since been expanded to cover this case in ES2016: https://github.com/tc39/ecma262/commit/d322357e6be95bc4bd3e03f5944a736aac55fa50

Not that I think this example is particularly readable :)

On Sun, May 29, 2016 at 10:36 AM, Renki Ivanko <[hidden email]> wrote:
It works in V8 at least, so I assumed it's correct.

On Sun, May 29, 2016 at 8:29 PM, Bob Myers <[hidden email]> wrote:
I'm quite sure this syntax is invalid.


On Sun, May 29, 2016 at 9:36 PM, Renki Ivanko <[hidden email]> wrote:
You can already do it like this:

```js
((...[,,foo]) => foo)(1, 2, 3) // -> 3
```


On Sun, May 29, 2016 at 6:53 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Renki Ivanko
In reply to this post by Bob Myers
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Cyril Auburtin
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss




_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Renki Ivanko
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Cyril Auburtin
Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss






_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Isiah Meadows-2

For what it's worth, elided array elements aren't available in strict mode (they're a syntax error), and it's not likely anyone is going to want to add a new sloppy mode only feature. Plus, it's not easy to tell at a glance if it's a typo or intentional. `Math.min(x,,y)` is a likely error, but a syntax error is much more informative than `NaN` or a very odd `undefined`. I don't see the point of not making it explicit.


On Mon, Aug 8, 2016, 06:34 Cyril Auburtin <[hidden email]> wrote:
Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Claude Pache

Le 10 août 2016 à 11:01, Isiah Meadows <[hidden email]> a écrit :

For what it's worth, elided array elements aren't available in strict mode

Are you sure?

—Claude


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Isiah Meadows-2

Okay. I'll admit I'm wrong here. I misremembered. I knew they were more of a legacy thing, I just didn't know they were available in strict mode.


On Wed, Aug 10, 2016, 05:37 Claude Pache <[hidden email]> wrote:
Le 10 août 2016 à 11:01, Isiah Meadows <[hidden email]> a écrit :

For what it's worth, elided array elements aren't available in strict mode

Are you sure?

—Claude

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Alan Johnson
In reply to this post by Cyril Auburtin
What if you could use a `.` as a wildcard? I don’t think it would conflict with existing syntax, and it would avoid binding a usable identifier. It would be more obvious than nothing between the commas.


On Aug 8, 2016, at 06:33, Cyril Auburtin <[hidden email]> wrote:

Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Bob Myers
Confused by this thread.

What if you could use a `.` as a wildcard? 

You can already use `_` or anything you want, as was already pointed out in early iterations of this idea.

it would avoid binding a usable identifier.

What is the problem with that?

What is the problem that this proposal is trying to solve? Any chance we could move on?

Bob



On Wed, Aug 10, 2016 at 7:48 PM, Alan Johnson <[hidden email]> wrote:
What if you could use a `.` as a wildcard? I don’t think it would conflict with existing syntax, and it would avoid binding a usable identifier. It would be more obvious than nothing between the commas.


On Aug 8, 2016, at 06:33, Cyril Auburtin <[hidden email]> wrote:

Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Cyril Auburtin
Confused by this thread.

It's quite simple though, _ would be a useless allocated variable, you an't have more than 1, ...

What is the problem that this proposal is trying to solve?

ignoring/skipping argument in functions declarations (indeed the invocations could be let apart)

> `Math.min(x,,y)`

yes this kind of thing would give NaN, that's why you can `Math.min(x, , y)` write it with more spaces to avoid a typo mistake, indeed you could still have like `Math.min(x, /*y (no longer used)*/ , z)` would. Like said above, I realize the function invocations are sensible.

So, it would be only for function declarations

`div.addEventListener('click', () => { } )` says to skip all arguments, and you've your callback scope is free of any additional vars

`arr.forEach( x => { } )` says to only consider first argument, others are skipped, and not in scope

`Array.from({length: 19}, (, i) => i )` would be similar for the second argument, similarly to array destructuring. It's not just for saving one character, that's really not the matter, it's for standardizing this way, because some people use `_`, some don't, ....

2016-08-10 16:27 GMT+02:00 Bob Myers <[hidden email]>:
Confused by this thread.

What if you could use a `.` as a wildcard? 

You can already use `_` or anything you want, as was already pointed out in early iterations of this idea.

it would avoid binding a usable identifier.

What is the problem with that?

What is the problem that this proposal is trying to solve? Any chance we could move on?

Bob



On Wed, Aug 10, 2016 at 7:48 PM, Alan Johnson <[hidden email]> wrote:
What if you could use a `.` as a wildcard? I don’t think it would conflict with existing syntax, and it would avoid binding a usable identifier. It would be more obvious than nothing between the commas.


On Aug 8, 2016, at 06:33, Cyril Auburtin <[hidden email]> wrote:

Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss




_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Kris Siegel
ignoring/skipping argument in functions declarations (indeed the invocations could be let apart)

I am of the opinion that this is not a problem that needs to be solved at the language standardization level. The commas (or really any separator) for "skipping" a parameter looks like a mistake and is unintuitive (it's certainly not obvious to me what its intent is had I seen it without the context of this thread).

This seems like a problem solved with better coding practices. I typically make required parameters first and then any optional ones in a separate, single parameter called options. Callbacks can be done with chaining / promises / I fmake them required / etc. Skipping callbacks usually isn't a good idea. We could talk all day about who's coding practice is better than who's but ultimately this problem should be solved by developing / adopting good coding practices.

(Honestly I'm not a fan of the skipping in arrays either but considering it's an array I feel like it's at least a magnitude less confusing than doing it with function parameters)

On Thu, Aug 11, 2016 at 4:00 AM, Cyril Auburtin <[hidden email]> wrote:
Confused by this thread.

It's quite simple though, _ would be a useless allocated variable, you an't have more than 1, ...

What is the problem that this proposal is trying to solve?

ignoring/skipping argument in functions declarations (indeed the invocations could be let apart)

> `Math.min(x,,y)`

yes this kind of thing would give NaN, that's why you can `Math.min(x, , y)` write it with more spaces to avoid a typo mistake, indeed you could still have like `Math.min(x, /*y (no longer used)*/ , z)` would. Like said above, I realize the function invocations are sensible.

So, it would be only for function declarations

`div.addEventListener('click', () => { } )` says to skip all arguments, and you've your callback scope is free of any additional vars

`arr.forEach( x => { } )` says to only consider first argument, others are skipped, and not in scope

`Array.from({length: 19}, (, i) => i )` would be similar for the second argument, similarly to array destructuring. It's not just for saving one character, that's really not the matter, it's for standardizing this way, because some people use `_`, some don't, ....

2016-08-10 16:27 GMT+02:00 Bob Myers <[hidden email]>:
Confused by this thread.

What if you could use a `.` as a wildcard? 

You can already use `_` or anything you want, as was already pointed out in early iterations of this idea.

it would avoid binding a usable identifier.

What is the problem with that?

What is the problem that this proposal is trying to solve? Any chance we could move on?

Bob



On Wed, Aug 10, 2016 at 7:48 PM, Alan Johnson <[hidden email]> wrote:
What if you could use a `.` as a wildcard? I don’t think it would conflict with existing syntax, and it would avoid binding a usable identifier. It would be more obvious than nothing between the commas.


On Aug 8, 2016, at 06:33, Cyril Auburtin <[hidden email]> wrote:

Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss




_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
Reply | Threaded
Open this post in threaded view
|

Re: Ignoring arguments

Isiah Meadows-2

If you're talking about ignored function parameters in a declaration or expression, much like `_` in several functional languages (like Haskell and Scala), I could see value in that. I'd prefer an explicit token for that, though, something like this:

```js
// ImmutableJS: convert map to list, only
// keeping values with integer keys
map
.filter((*, key) => typeof key === "number" && key % 1 === 0)
.toList()
```


On Thu, Aug 11, 2016, 12:51 Kris Siegel <[hidden email]> wrote:
ignoring/skipping argument in functions declarations (indeed the invocations could be let apart)

I am of the opinion that this is not a problem that needs to be solved at the language standardization level. The commas (or really any separator) for "skipping" a parameter looks like a mistake and is unintuitive (it's certainly not obvious to me what its intent is had I seen it without the context of this thread).

This seems like a problem solved with better coding practices. I typically make required parameters first and then any optional ones in a separate, single parameter called options. Callbacks can be done with chaining / promises / I fmake them required / etc. Skipping callbacks usually isn't a good idea. We could talk all day about who's coding practice is better than who's but ultimately this problem should be solved by developing / adopting good coding practices.

(Honestly I'm not a fan of the skipping in arrays either but considering it's an array I feel like it's at least a magnitude less confusing than doing it with function parameters)

On Thu, Aug 11, 2016 at 4:00 AM, Cyril Auburtin <[hidden email]> wrote:
Confused by this thread.

It's quite simple though, _ would be a useless allocated variable, you an't have more than 1, ...

What is the problem that this proposal is trying to solve?

ignoring/skipping argument in functions declarations (indeed the invocations could be let apart)

> `Math.min(x,,y)`

yes this kind of thing would give NaN, that's why you can `Math.min(x, , y)` write it with more spaces to avoid a typo mistake, indeed you could still have like `Math.min(x, /*y (no longer used)*/ , z)` would. Like said above, I realize the function invocations are sensible.

So, it would be only for function declarations

`div.addEventListener('click', () => { } )` says to skip all arguments, and you've your callback scope is free of any additional vars

`arr.forEach( x => { } )` says to only consider first argument, others are skipped, and not in scope

`Array.from({length: 19}, (, i) => i )` would be similar for the second argument, similarly to array destructuring. It's not just for saving one character, that's really not the matter, it's for standardizing this way, because some people use `_`, some don't, ....

2016-08-10 16:27 GMT+02:00 Bob Myers <[hidden email]>:
Confused by this thread.

What if you could use a `.` as a wildcard? 

You can already use `_` or anything you want, as was already pointed out in early iterations of this idea.

it would avoid binding a usable identifier.

What is the problem with that?

What is the problem that this proposal is trying to solve? Any chance we could move on?

Bob



On Wed, Aug 10, 2016 at 7:48 PM, Alan Johnson <[hidden email]> wrote:
What if you could use a `.` as a wildcard? I don’t think it would conflict with existing syntax, and it would avoid binding a usable identifier. It would be more obvious than nothing between the commas.


On Aug 8, 2016, at 06:33, Cyril Auburtin <[hidden email]> wrote:

Just bumping this up

Calling `foo(1)` where foo is defined with 3 arguments, lets the 2 others undefined, this behavior is already a bit magic and similar to the behavior of an array, so I still think foo(a,,b,,,c) should be like foo(...[a,,b,,,c])

Other example:
```
var m=new Map([[1], [2,], [3,7]]) // Map {1 => undefined, 2 => undefined, 3 => 7} // here commas fantasies are allowed in arrays
m.set(3) // Map {1 => undefined, 2 => undefined, 3 => undefined} // setting implicitely value as undefined
m.set(3, ) // not allowed, which should be m.set(...[3,])
```

and again, it would help for callbacks too, `something( ( , , thirdArg) => {} )`

I saw this https://jeffmo.github.io/es-trailing-function-commas/, it seems like a sub-case

2016-05-29 23:07 GMT+02:00 Renki Ivanko <[hidden email]>:
One more similarity is that both function parameters and destructuring allow default values: (foo = 1) vs [foo = 1].



On Sun, May 29, 2016 at 11:56 PM, Cyril Auburtin <[hidden email]> wrote:
Since functions arguments is an array under the hood, they could 'more behave the same'

Both function arguments and arrays accept spreading: [1, 2, ...args]  and fn(1, 2, ...args)

a function definition like (,i) => {}, would be the equivalent of var [,i] = arguments

an invocation fn(,,i) would be the equivalent of [,,i]

It's possible with (...[,i]) => {}, (_,i)=>{} like Renki said, but slightly less simply

Are there possible issues with that 'extension' of function syntax?


2016-05-29 21:32 GMT+02:00 Renki Ivanko <[hidden email]>:
You could stop with "rare"; having to make up unused names is an obvious smell in comparison.

```js
foo(UNUSED1, UNUSED2, x)

foo(_, __, x)

foo(,, x)

foo(...[,, x])
```

The latter is shorter and more explicit and would not be any more confusing if it became common. 


On Sun, May 29, 2016 at 8:46 PM, Bob Myers <[hidden email]> wrote:
Eliding array elements is not "similar" to eliding function formal parameters. The latter is extremely rare, hardly readable, confusing, bug-prone, and unnecessary because there is already a "standard way" which is to use any old parameter name you want:

```js
function foo(UNUSED1, UNUSED2, x)
````

Most linters will not complain, or there are ways to shut them up if they do.

If you want to throw away an argument, just throw it away.

```js
function skipFirstParam(fn) { return ((first, ...args) => fn(...args)); }

`[1,2,3,4].map(skipFirstParam(i => i));

```

Or use Renki's solution.

Bob


On Sun, May 29, 2016 at 9:23 PM, Cyril Auburtin <[hidden email]> wrote:
Similarly to:

`var [,x,,y] = [1,2,3,4,5,6];`

I think it could be interesting to let a field empty in function arguments

`[1,2,3,4].map( (,i) => i )`, `Array.from({length:10}, (,i) => i )`

`function test(a,,b) { }`

(but that would alter the current parsing, that doesn't allow it)

Currently I often use `_` as a way to mark ignored fields, but when there are more than 1 you need another identifier. A standard way would be interesting rather

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss



_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss





_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss




_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss


_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss

_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss
12