Issue #11385 has been updated by Benoit Daloze.


Benoit Daloze wrote:
> Should the result not be **false** instead?
> These two instances each have a different @friend and it cannot be determined if they are equal so "false" seems a much safer answer.
> 
> Also, this seems inconsistent to how Comparable#== treat such cases:
> 
> ~~~
> class Something
>   attr_accessor :friend
>   def initialize(friend)
>     self.friend = friend
>   end
>   include Comparable
>   def <=>(other)
>     friend <=> other
>   end
> end
> a = Something.new([])
> b = Something.new([a])
> a.friend = [b]
> p a == b # false (and not true like above!)
> ~~~

I forgot to call #friend on other in <=> so this also returns true.

Yet, I am not sure whether "true" is a good return value in this scenario.

----------------------------------------
Bug #11385: `==` with bidirectional/cyclic dependency
https://bugs.ruby-lang.org/issues/11385#change-53544

* Author: Allen Wang
* Status: Rejected
* Priority: Normal
* Assignee: ruby-core
* ruby -v: 2.2.1
* Backport: 2.0.0: UNKNOWN, 2.1: UNKNOWN, 2.2: UNKNOWN
----------------------------------------
```ruby
class Something
  attr_accessor :friend
  def initialize(friend)
    self.friend = friend
  end

  def ==(other)
    friend == other.friend
  end
end


a = Something.new([])
b = Something.new([a])
a.friend = [b]

a == b
```

The above code returns true on OS X and Linux, by right it should give me a exception of stack level too deep.

( And on windows I can see the expected exception )

---Files--------------------------------
test.rb (226 Bytes)


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