Issue #19559 has been updated by austin (Austin Ziegler). What would be the result of the pathological cases? ```ruby +:"-chomp" -(-:chomp) ``` With the proposed implementation, it would be `:"-chomp"` and `:"--chomp"`, but those both feel wrong. If we wanted to accept non-keyword arguments for `gets` and `Integer`, I would support more `:no_chomp` or `:no_exxception`. Unless of course, this is a very early poisson d’Avril, in which case I think we need to have *more* unary operators on symbols so we can implement BF entirely with symbols. ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102592 * Author: sawa (Tsuyoshi Sawada) * Status: Open * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by vo.x (Vit Ondruch). One of the benefits or Ruby used to be readability. There were great times when `Integer("2.3", :exception => false)` was standard. Than came the JS hash notation `Integer("2.3", exception: false)` which have not improved the situation and now this `Integer("2.3", -:exception)`? IOW I am against this proposal, because it will make the code less readable. ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102596 * Author: sawa (Tsuyoshi Sawada) * Status: Open * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by mame (Yusuke Endoh). rubyFeedback (robert heiler) wrote in #note-5: No ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102599 * Author: sawa (Tsuyoshi Sawada) * Status: Open * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by sawa (Tsuyoshi Sawada). @austin (Austin Ziegler) I see that you have logged in. I strongly urge you to remove that sentence or your entire comment. ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102882 * Author: sawa (Tsuyoshi Sawada) * Status: Rejected * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by sawa (Tsuyoshi Sawada). Dear moderators Please ban user austin (Austin Ziegler). ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102888 * Author: sawa (Tsuyoshi Sawada) * Status: Rejected * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by matz (Yukihiro Matsumoto). I don't see any problem in Austin's comment (#note-2) neither. Probably there's some misunderstanding (lost in translation?). If @sawa has any further comment or complaint, contact us in Japanese. Matz. ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102891 * Author: sawa (Tsuyoshi Sawada) * Status: Rejected * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by sawa (Tsuyoshi Sawada). 以下のコメントに付き、松本さん以外の開発者の方でも対処できる方がいれば、対処をお願いします。 ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102936 * Author: sawa (Tsuyoshi Sawada) * Status: Rejected * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by matz (Yukihiro Matsumoto). 私を含めた多くの人には #note-3 で @sawa さんが突然怒りだしたように見えます。少なくともその時点で「真剣に提案したものをエイプリルフールジョーク扱いするのは失礼だ」と感じたことは表明しておくべきではなかったでしょうか。また、自分が真剣に提案したものがエイプリルフールジョークだと思われて傷ついたという気持ちは理解できないことはないですが、だからと言って、それに対してコメントの削除なり、追放なりを求めるのはやりすぎだと思います。「私は真剣だった」、「そうでしたか」で終わるべき対話だったと感じています。 To many people, including me, @sawa seemed to suddenly get angry in #note-3. At least at that point, You should have expressed that you felt it was rude to treat a serious proposal as an April Fool's joke. Also, I can understand your feeling of being hurt by someone thinking that what you seriously proposed was an April Fool's joke, but that doesn't mean you should ask for the comment to be deleted or banned. I think it's overkill. I feel that the dialogue should end with “I was serious” and “OK”. ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-102971 * Author: sawa (Tsuyoshi Sawada) * Status: Rejected * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/

Issue #19559 has been updated by austin (Austin Ziegler). sawa (Tsuyoshi Sawada) wrote in #note-17: I’ve stayed out of this for the most part, but I want to address this. I was not involved in the Ruby community conduct conversations, but I have been involved in several and have pushed the adoption of a similar community conduct for our company's stance. The meaning of "always assume good intentions" does not mean what you think it means above. It means that, when having conversations, one should *not* assume that there are *bad* intentions. It does not mean that one must take every proposal entirely seriously. (It does not excuse malice disguised as humour, but there is absolutely no malicious sentiment to be found in that single sentence.) In terms of assuming good intentions, you did not do that when you saw my response as an attack on you and your proposal. It was not. My initial response to your proposal both addressed your proposal seriously *and* suggested it had some humour possibilities, which was shared by other respondents. If anyone else had made a similar proposal, I probably would have responded the same way. I am sorry that what I wrote has given offence. In the future, I shall always treat your proposals as entirely serious unless you indicate that it is, in fact, a joke proposal. ---------------------------------------- Feature #19559: Introduce `Symbol#+@` and `Symbol#-@`, and eventually replace boolean arguments with symbols https://bugs.ruby-lang.org/issues/19559#change-103212 * Author: sawa (Tsuyoshi Sawada) * Status: Rejected * Priority: Normal ---------------------------------------- I propose to define `Symbol#+@` and `Symbol#-@`, so that we can add positive or negative polarity to symbols. A possible implementation can be equivalent to what can be achieved by this: ```ruby class Symbol def -@; "-#{self}".to_sym end def +@; self end end ``` The intention behind this is to, eventually, replace boolean positional or keyword arguments with symbols so that, instead of this: ```ruby "foo".methods(false) gets(chomp: true) Integer("2.3", exception: false) ``` we can write like this: ```ruby "foo".methods(-:inherit) gets(+:chomp) Integer("2.3", -:exception) ``` -- https://bugs.ruby-lang.org/