[Proposal] Optional chaining

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

[Proposal] Optional chaining

Beknar Askarov

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  


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

Re: [Proposal] Optional spreading

Scott Rudiger
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Jordan Harband
Since you can do this now with:

```js
[
  1,
  ...(condition ? [2, 3] : []),
  3,
]
```
and object spreading already handles this for you, is extra syntax really needed?

On Thu, Aug 22, 2019 at 6:52 PM Scott Rudiger <[hidden email]> wrote:
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Beknar Askarov
In reply to this post by Scott Rudiger
Indeed. I see your point.

But it really needs to be falsy check.
Since falsy values are not "spreadable" 



On Fri, 23 Aug 2019, 03:52 Scott Rudiger, <[hidden email]> wrote:
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Beknar Askarov
@Scott My mistake empty string [...""] is spreadable.
But not sure if it is desirable behavior.


On Fri, 23 Aug 2019, 04:42 Beknar Askarov, <[hidden email]> wrote:
Indeed. I see your point.

But it really needs to be falsy check.
Since falsy values are not "spreadable" 



On Fri, 23 Aug 2019, 03:52 Scott Rudiger, <[hidden email]> wrote:
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Beknar Askarov
And it does result in empty array

[...''] -> []

So not much difference even if it passes through. Everything else would result in error if check was only nullish

On Fri, 23 Aug 2019, 04:55 Beknar Askarov, <[hidden email]> wrote:
@Scott My mistake empty string [...""] is spreadable.
But not sure if it is desirable behavior.


On Fri, 23 Aug 2019, 04:42 Beknar Askarov, <[hidden email]> wrote:
Indeed. I see your point.

But it really needs to be falsy check.
Since falsy values are not "spreadable" 



On Fri, 23 Aug 2019, 03:52 Scott Rudiger, <[hidden email]> wrote:
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Cyril Auburtin
Like others said, this idea is good, but I think we can already achieve something decent and succinct enough

arrays:
```js
// group by name, and accumulate data:
arr.reduce((m, {name, data, ...o}) => m.set(name, {...o, data: [...m.get(name)?..data||[], ...data]}), new Map())
```
objects: `{foo: 1, ...cond && {bar: 2}, qux: 3}`


On Fri, Aug 23, 2019 at 5:01 AM Beknar Askarov <[hidden email]> wrote:
And it does result in empty array

[...''] -> []

So not much difference even if it passes through. Everything else would result in error if check was only nullish

On Fri, 23 Aug 2019, 04:55 Beknar Askarov, <[hidden email]> wrote:
@Scott My mistake empty string [...""] is spreadable.
But not sure if it is desirable behavior.


On Fri, 23 Aug 2019, 04:42 Beknar Askarov, <[hidden email]> wrote:
Indeed. I see your point.

But it really needs to be falsy check.
Since falsy values are not "spreadable" 



On Fri, 23 Aug 2019, 03:52 Scott Rudiger, <[hidden email]> wrote:
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional chaining

Michael Luder-Rosefield
In reply to this post by Beknar Askarov
Another similar thing I've used is with String interpolation; if you use a similar pattern, e.g.,

``` `$[items.length} item${items.length !== 1 ? 's' : ''} in collection` ```

When you want to conditionally add either some text, or nothing at all, you are forced to use the ternary with an empty string, or some workaround. In terms of a proposal, the first thing I think we need to know is: can the interpreter detect that it's in a template literal, in the same manner as it detects ?...  being in an object/array declaration context?
--------------------------
Dammit babies, you've got to be kind.


On Fri, 23 Aug 2019 at 02:01, Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Beknar Askarov
In reply to this post by Beknar Askarov
@Scott Rudiger After thinking more about it.
I would not like to conflict with semantics of optional chaining and null coalescing operator.
So in order to not confuse people, maybe introduce two types of optional spread operators


1. `?...` - Do not spread if nullish. Note nullish. Else try to spread.
Signature Array: [?...(nullish | Iterable)];
Signature Object: {?...(nullish | object)};

2. `!...` - Do not spread if false. Note FALSE not falsy. Else try to spread.
Signature Array: [!...(false | Iterable)];
Signature Object: {!...(false | object)};

I think this can be an option to avoid consfusion

Why not `!...` to check for all falsy and do not spread of falsy?
To avoid confusion and make developers to know their types

For example:

```js
[!...(0 ?? [1 , 2])]; // throws TypeError. number 0 is not iterable
```

So better will be to use:
```js
[!...(!!0 ?? [1 , 2])];
// OR
[?...(0 ?? [1 , 2])];
```

What do you think?

On Fri, Aug 23, 2019 at 5:00 AM Beknar Askarov <[hidden email]> wrote:
And it does result in empty array

[...''] -> []

So not much difference even if it passes through. Everything else would result in error if check was only nullish

On Fri, 23 Aug 2019, 04:55 Beknar Askarov, <[hidden email]> wrote:
@Scott My mistake empty string [...""] is spreadable.
But not sure if it is desirable behavior.


On Fri, 23 Aug 2019, 04:42 Beknar Askarov, <[hidden email]> wrote:
Indeed. I see your point.

But it really needs to be falsy check.
Since falsy values are not "spreadable" 



On Fri, 23 Aug 2019, 03:52 Scott Rudiger, <[hidden email]> wrote:
I like it; code seems cleaner to me with its use. However, since the syntax is so similar to optional chaining, it's too bad your goal with this sample is to check for falsey values rather than nullish values.

[ 1, ?...(condition && [2, 3]), // no extras:) 3, ]

On Thu, Aug 22, 2019, 6:01 PM Beknar Askarov <[hidden email]> wrote:

Problem

Spreading is great! It contributes towards "declerativity" of the language and reduces verbosity. I see one more feature to add to improve it.

Consider following

[
  1,
  condition && 2,
  condition && 3,
  4,
].filter(Boolean) // filtering needed to remove falsy values

// Results in 
[1, 2, 3, 4] // if condition is `truthy`
// and
[1, 4] // if not truthy.

Another way to achieve the same result without the need of filtering after

[
  1,
   ...(condition ? [2, 3] : []), // note extra [] in the end, to avoid errors
  4,
]

Similar pattern with objects

{
  ...(condition ? { foo: 'bar' } : {}), // extra {}
}

Another pattern is when condition is the object itself, when it is known that type is one or falsy

[
  item1,
  item2,
  ...(itemsOrNull || []) // extra []
]

Similar for objects

{
  ...(obj || {}), // extra {}
}

I see these patterns appearing very often. And these are cleanest examples I have seen so far.

Proposal

Optional spreading

With condition

// Arrays
[
  1,
  ?...(condition && [2, 3]), // no extras:)
  3,
]
// Objects
{
  ?...(condition && { foo: 'bar' }) // no extras:)
}

When condition is the object

[
  item1,
  item2,
  ?...itemsOrNull // no extras at all:) even (...)
]

These look nicer and can be good for performance since (?...), since no cleanup is needed after to remove falsy values or extra spreading even when it is not needed.

Looks intuitive (since: https://github.com/tc39/proposal-optional-chaining)
Plays nice with typeings.

What do you think? https://es.discourse.group/t/optional-spreading/93  

_______________________________________________
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: [Proposal] Optional spreading

Herby Vojčík
On 23. 8. 2019 16:24, Beknar Askarov wrote:

> @Scott Rudiger After thinking more about it.
> I would not like to conflict with semantics of optional chaining and
> null coalescing operator.
> So in order to not confuse people, maybe introduce two types of optional
> spread operators
>
>
> 1. `?...` - Do not spread if nullish. Note nullish. Else try to spread.
> Signature Array: [?...(nullish | Iterable)];
> Signature Object: {?...(nullish | object)};
>
> 2. `!...` - Do not spread if false. Note FALSE not falsy. Else try to
> spread.

I read

   !...foo

as

   !(...foo)

that is, logical not. I'd tip it already works that way. In which case
no go, break compat.

Herby

> Signature Array: [!...(false | Iterable)];
> Signature Object: {!...(false | object)};
>
> I think this can be an option to avoid consfusion

Or add a new one. :-(
_______________________________________________
es-discuss mailing list
[hidden email]
https://mail.mozilla.org/listinfo/es-discuss