From: "alexeymuranov (Alexey Muranov)" <redmine@...>
Date: 2013-01-25T19:08:28+09:00
Subject: [ruby-core:51667] [ruby-trunk - Feature #7738] Deprecate Set#+ as an alias of Set#|, use it for symmetric difference.  Introduce Hash#| for Hash#reverse_merge in Rails.


Issue #7738 has been updated by alexeymuranov (Alexey Muranov).


I agree that having the same symbol for the symmetric difference as for XOR would be nice, given that there are not so many different ASCII symbols. However, the main part of my request is to *not use '+' for the union of set*. This use is inconsistent with set theory notation (or i have not yet met '+' for the union), and is not very consistent in my opinion with other uses of '+' in Ruby. Also it looks redundant to alias one symbol with another: a half of rubists will be using one, and another half will be using another.

If `Set#+` is used, in my opinion it should be the symmetric difference. (The problem with this is that i cannot come up with a good use case for the symmetric difference operation. I was thinking about flipping a subset of binary options, but do not see how it can be useful.)

About the inconsistency with the `Fixnum#^` (i don't like `#^` for XOR either, i proposed `#><` some time but it was rejected), i can say that this is in a sense a secondary operation on `Fixnum`, which violates to some extent the Single Responsibility Principle. In my opinion, for bitwise operations it would be natural to have some `BitSet` class, and use, for example, `BitSet#+` for XOR. There seem to be no special reason for `Fixnum` to be stored internally in the binary form, there existed ternary computers once upon a time: http://en.wikipedia.org/wiki/Setun
----------------------------------------
Feature #7738: Deprecate Set#+ as an alias of Set#|, use it for symmetric difference.  Introduce Hash#| for Hash#reverse_merge in Rails.
https://bugs.ruby-lang.org/issues/7738#change-35633

Author: alexeymuranov (Alexey Muranov)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: Next Major


=begin
I am almost sure this will be rejected, but i want to try anyway.  My goal is to propose a more efficient and consistent use of binary operator symbols for some classes, in this case for (({Set})) and (({Hash})).

I propose to deprecate (({Set#+})) as an alias of (({Set#|})), and use (({Set#+})) later for the ((*symmetric difference*)) of sets.  I think that operator symbols like (({+})) and (({|})) are too precious to alias one another.

Currently (({Set#+})) is probably the only use of (({#+})) for an operation which is not ((*injective*)) in each of the arguments: for sets (({a})), (({b})), (({c})), the equality

  a + b == a + c

does not currently imply

  b == c

The natural binary operation on sets that is injective in each argument is the ((*symmetric difference*)), it corresponds to the bitwise XOR.  I have also noticed that the "(({+}))" for sets is used in "Lectures on ergodic theory " by P. Halmos to denote the symmetric difference.

I also suggest for to define (({Hash#|})) as Hash#reverse_merge in Rails, in my opinion this would correspond nicely to (({Set#|})).
=end



-- 
http://bugs.ruby-lang.org/