Short Comparing proposal

[kdex]

I actually don't think this is worth pursuing, as it can easily be 
implemented
by libraries once we solve operator overloading, without adding new syntax:

``
   if (1 < [2, 3])
``

Am 01.02.2017 um 18:12 schrieb Ryan Birmingham:
> I have a handfull of questions on this proposal as well:
> How would your proposal look with three or four things to check 
> against? Would the collection of things to check against be a variable?
> Would this be syntactic sugar to the array includes method, or would 
> this be something entirely new?
>
> -Ryan Birmingham
>
> On 1 February 2017 at 12:03, Felipe Nascimento de Moura 
> <felipenmoura at gmail.com <mailto:felipenmoura at gmail.com>> wrote:
>
>     I see...
>     we could perhaps think on some other approach.
>
>     What about:
>     if (obj.prop.prop ?== 'a' : 'b')
>
>     This way, we have "?==", which is not too chocking once we already
>     got "!==", and this kinda prepares the engine to deal with the
>     next values as part of the comparison.
>     Also, feels familiar due to " something ? 'a' : 'b' "
>
>     Personally, I don't feel that comfortable with this syntax.
>     We could think on different a token as well
>
>     if (obj.prop.prop === (? 'a' : 'b')) // feels like a ternary, but
>     without the first statement
>     if (obj.prop.prop === ('a'  | 'b'))) // could break the web once
>     it is already valid syntax (although not very used)
>     if (obj.prop.prop === ('a' :: 'b')) // perhaps a double colon
>
>     Anyways, open for suggestions :)
>
>
>
>
>     On Wed, Feb 1, 2017 at 2:48 PM Ryan Birmingham
>     <rainventions at gmail.com <mailto:rainventions at gmail.com>> wrote:
>
>         I like the idea, and I generally agree that your proposal
>         would increase readability, but I'm not a fan of the colon in
>         parenthesis.
>         In this context, the colon looks like it should represent a
>         member assignment of 'b' to 'a'.
>
>
>         -Ryan Birmingham
>
>         On 1 February 2017 at 11:27, Felipe Nascimento de Moura
>         <felipenmoura at gmail.com <mailto:felipenmoura at gmail.com>> wrote:
>
>             Hi.
>
>             I wonder if there is already a proposal for such thing or
>             if it would be something interesting to be proposal:
>
>             *The motivation:*
>             Let's say you have an object whose property you want to
>             compare to 'a' or 'b':
>
>             ```
>             if (object.property.secondProp === 'a' ||
>             object.property.secondProp === 'b') {
>               // do something
>             }
>             ```
>
>             *The proposal:*
>             Now, with this syntax you would be able to perform such
>             comparisons in a much simpler, better to read approach:
>
>             ```
>             if (object.property.secondProp === ('a' : 'b')) {
>                 // do Something
>             }
>             ```
>
>             And with the advance of the Optional Chaining Operator
>             <https://github.com/claudepache/es-optional-chaining> proposal,
>             it would get even better, like so:
>
>             ```
>             // this:
>             if (object &&
>             object.property &&
>             (object.property.secondProp === 'a' ||
>             object.property.secondProp === 'b')) {
>               // ...
>             }
>
>             // becomes this:
>             if (object?.property?.secondProp === ('a' : 'b')) { ... }
>             ```
>
>             *Alternatives:*
>             I do know that we could accomplish that with other
>             techniques, like:
>
>             ```
>             ['a', 'b'].includes(object.property.secondProp)
>             ```
>
>             I just think it might be counterintuitive and having a
>             syntax for a "short comparing" would be better for reading
>             and understanding.
>
>             Would make ternary comparison even shorter, too:
>
>             ```
>             let currentState = object.property.status === ('fail' :
>             'ok') ? 'done' : 'doing'
>             ```
>
>             Please let me hear your thoughts on that :)
>
>             Regards.
>
>
>
>
>
>
>
>             _______________________________________________
>             es-discuss mailing list
>             es-discuss at mozilla.org <mailto:es-discuss at mozilla.org>
>             https://mail.mozilla.org/listinfo/es-discuss
>             <https://mail.mozilla.org/listinfo/es-discuss>
>
>
>
>
>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20170201/d7382f91/attachment-0001.html>