even stensberg (2016-04-17T13:21:16.000Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries - long & !clean codelines
-default params (ES) , though it won't be a general use case

There is already a lot of assignment, string and so on operators, but I
don't really seem any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more clean and it makes sense.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.
( Perhaps I'm both).

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20160417/d0a3281c/attachment.html>
evenstensberg at gmail.com (2016-04-17T14:54:00.054Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines, or default params (ES), of which, won't be a general use case when it comes down to supporting the feature fully.

There are already lots of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense, enhancing assignments even more. One way or another, it seems like this should have been implemented a long time ago, not when it's broadly used.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:52:34.680Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines, or default params (ES), of which, won't be a general use case when it comes down to supporting the feature fully.

There are already lots of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense enhancing this even more. One way or another, it seems like this should have been implemented a long time ago, not when it's broadly used.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:52:09.946Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines, or default params (ES), of which, won't be a general use case when it comes down to supporting the feature fully.

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense enhancing this even more. One way or another, it seems like this should have been implemented a long time ago, not when it's broadly used.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:51:32.644Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines, or default params (ES), of which, won't be a general use case when it comes down to a broad support. 

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense enhancing this even more. One way or another, it seems like this should have been implemented a long time ago, not when it's broadly used.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:51:09.567Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines, or default params (ES) won't be a general use case when it comes down to a broad support. 

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense enhancing this even more. One way or another, it seems like this should have been implemented a long time ago, not when it's broadly used.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:49:56.474Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines,  and default params (ES) won't be a general use case when it comes down to a broad support. 

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense enhancing this even more. One way or another, it seems like this should have been implemented a long time ago, not when it's broadly used.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:48:46.544Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines,  and default params (ES) won't be a general use case when it comes down to a broad support. 

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. One way or another, it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:46:22.016Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines,  and default params (ES) won't be a general use case when it comes down to a broad support. 

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. One way or another, it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:45:18.562Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean code lines,  and default params (ES) won't be a general use case when it comes down to a broad support. 

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:44:36.343Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean codelines and default params (ES) won't be a general use case when it comes to this.

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:44:15.563Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-Tenaries, which will result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:43:46.851Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check out these three links:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx

http://web.eecs.umich.edu/~bartlett/jsops.html

http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:24:09.866Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:23:32.745Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more better and it makes sense too.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.
( Perhaps I'm both).

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:23:10.923Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I've come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more clean and it makes sense.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.
( Perhaps I'm both).

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T14:22:39.374Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignments out there, but I
don't really see any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more clean and it makes sense.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.
( Perhaps I'm both).

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T13:26:02.157Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines and default params (ES) won't be a general use case

There is already a lot of assignment, string and so on operators, but I
don't really seem any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more clean and it makes sense.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.
( Perhaps I'm both).

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.
evenstensberg at gmail.com (2016-04-17T13:25:24.503Z)
I've seen a lot of code using an extra type to have as a fallback. This to
me seems like not a very good way of putting use of the logical OR. Here's
an example:

`var itemList = itemList || 'something went extremely wrong'`


This is a really hacky way of doing things. I don't think you should assign
your variable to a default by doing this.


Been back and forth by this "issue" with some of the ReactJS members at
GitHub, and while saying this is a "stylus" thing, I disagree. It is more
about not reiterating your code.

Options could be:

-tenaries result in long & !clean codelines
-default params (ES) , though it won't be a general use case

There is already a lot of assignment, string and so on operators, but I
don't really seem any of them touch this, except maybe the bit-wise OR
assignment Operator. To read more about that, check these two links out:

https://msdn.microsoft.com/en-us/library/81bads72(v=vs.94).aspx
http://web.eecs.umich.edu/~bartlett/jsops.html
http://stackoverflow.com/a/14871137/5893008

And that is really not the use case here. We don't want a bit-wise, we want
a logical OR.

So here is what I come up with. It's not rocket science but ... nah, it's
pretty straight forward..

`var listItem || = 'I love open source!'`


For me, this is one thousand times more clean and it makes sense.
JavaScript teaches us and wants us to use `+ =`,` - =` and any other type
of "abbreviation" , so this makes perfectly sense for me. Either I'm crazy,
but it seems like this should have been implemented a long time ago.
( Perhaps I'm both).

Implementation will be another issue, but let us discuss that too( just
keep in mind this is conceptional)


Without further ado, I leave this up to you to discuss, and hopefully a
champion to fetch up to the committee.