Issue #16990 has been updated by marcandre (Marc-Andre Lafortune).


knu (Akinori MUSHA) wrote in #note-4:
> We can probably define Set#to_ary if it's OK, and Array#+ will be able to deal with a set.  Let us think about the downsides...

While this may be a good thing, and at least make them interoperable, it is still quite inefficient... For example, `Array#-` would call `to_ary`, which would create a temporary array from the hash, only to create a temporary hash/set...

> As for the result type, I think Array operators should return arrays. Otherwise array += set would turn the variable array to a Set and that would be a surprise.

Indeed. I'm glad we agree 

----------------------------------------
Feature #16990: Sets: operators compatibility with Array
https://bugs.ruby-lang.org/issues/16990#change-87436

* Author: marcandre (Marc-Andre Lafortune)
* Status: Open
* Priority: Normal
----------------------------------------
We currently have `set <operator> array` work fine:

```ruby
Set[1] + [2] # => Set[1, 2]
```

Nothing works in the reverse order:

```ruby
[1] + Set[2] # => no implicit conversion of Set into Array
# should be:
[1] + Set[2] # => [1, 2]
```

#### set-like operators

Note that the situation is particularly frustrating for `&`, `|` and `-`.
If someone wants to do `ary - set`, one **has** to do `ary - set.to_a` which will, internally, do a `to_set`, so what is happening is `set.to_a.to_set`!! (assuming `ary` is over `SMALL_ARRAY_LEN == 16` size, otherwise it's still doing in `O(ary * set)` instead of `O(ary)`).

The same holds with `&` and `|`; see order issue as to why this can *not* (officially) be done any other way.

Reminder:
```ruby
ary & ary.reverse # => ary
Set[*ary] & Set[*ary.reverse]  # => Set[*ary.reverse], officially order is indeterminate
```




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

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>