Issue #13606 has been updated by glebm (Gleb Mazovetskiy). shevegen (Robert A. Heiler) wrote: > [...] but they are not entirely the same are they? Different > object id for most objects for example. But it also may be that I did not fully > understand the proposal yet. Most objects in Ruby are compared semantically even if the object IDs are different, including `Array` and `Hash`. > What would the speed penalty be if one exists? If the `Enumerator`s have different `object_id`s, previous the equality check was `O(1)` but is `O(n)` with this proposal (just like for `Array`). > I guess the latter one could be > handled by some "behavioural switch" for people who need the behaviour > desscribed in the proposal, so a use-case example would be helpful. I am not proposing a behavioural switch. This should be a backwards-incompatible change. Use cases are the same as for arrays, except when the "arrays" are "lazy". Example: ~~~ ruby [1, 2, 3].reverse == [3, 2, 1] #=> true [1, 2, 3].reverse_each == [3, 2, 1] #=> false [1, 2, 3].reverse_each == [1, 2, 3].reverse_each #=> false ~~~ With this proposal, the last two are also `true`. ---------------------------------------- Feature #13606: Enumerator equality and comparison https://bugs.ruby-lang.org/issues/13606#change-65141 * Author: glebm (Gleb Mazovetskiy) * Status: Feedback * Priority: Normal * Assignee: * Target version: ---------------------------------------- In Ruby, most objects are compared by value. What do you think about `Enumerator`s following the same pattern? I think this would greatly increase the expressiveness of Ruby. Proposal: Two `Enumerator`s should be considered equal (`==`) if they yield the same number of elements and these elements are equal (`==`). If both of the `Enumerator`s are infinite, the equality operator never terminates. `<=>` should be handled similarly. -- 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>