* [ruby-core:109590] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#==
@ 2022-08-20 12:05 Eregon (Benoit Daloze)
2022-08-20 16:21 ` [ruby-core:109600] " ko1 (Koichi Sasada)
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: Eregon (Benoit Daloze) @ 2022-08-20 12:05 UTC (permalink / raw
To: ruby-core
Issue #18969 has been reported by Eregon (Benoit Daloze).
----------------------------------------
Feature #18969: Compare only method definitions for Method#== and UnboundMethod#==
https://bugs.ruby-lang.org/issues/18969
* Author: Eregon (Benoit Daloze)
* Status: Open
* Priority: Normal
----------------------------------------
From https://bugs.ruby-lang.org/issues/18751#note-16
During the last dev meeting, @ko1 said Method#== should be "is it the same definition?" and I agree.
In #18751 I did it for zsuper methods (was necessary for compatibility).
But maybe we should do it for all methods.
Currently, Method#== and UnboundMethod#== compare the method definitions, but also (I think, the code is not that clear) on which receiver/class the method was fetched (klass for `klass.instance_method(name)` or `obj` for `obj.method(name)`).
(Maybe it checks the `#owner` too? I'm unsure)
This proposal is to do only the first: compare the method definitions.
So for instance:
```ruby
class A
def foo
end
end
class B < A
end
p A.instance_method(:foo) # => #<UnboundMethod: A#foo() method_eq.rb:2>
p A.instance_method(:foo).owner
p B.instance_method(:foo) # => #<UnboundMethod: B(A)#foo() method_eq.rb:2>
p B.instance_method(:foo).owner
p A.instance_method(:foo) == B.instance_method(:foo) # currently false, with proposal true
p A.new.method(:foo) == B.new.method(:foo) # currently false, with proposal true
# Current workaround needed to compare definitions:
m1, m2 = A.instance_method(:foo), B.instance_method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
m1, m2 = A.new.method(:foo), B.new.method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
```
I think this is the main usage of Method#== and UnboundMethod#==, to compare "is it the same method definition?".
OTOH, if we think this is not good for #== we could add `{Method,UnboundMethod}#same_definition?(other)`. `same_definition?` has the slight advantage that it could be true for `Method#same_definition?(UnboundMethod)` and vice versa.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 4+ messages in thread
* [ruby-core:109600] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#==
2022-08-20 12:05 [ruby-core:109590] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#== Eregon (Benoit Daloze)
@ 2022-08-20 16:21 ` ko1 (Koichi Sasada)
2022-08-20 19:45 ` [ruby-core:109601] " Eregon (Benoit Daloze)
2022-08-20 19:52 ` [ruby-core:109604] " Eregon (Benoit Daloze)
2 siblings, 0 replies; 4+ messages in thread
From: ko1 (Koichi Sasada) @ 2022-08-20 16:21 UTC (permalink / raw
To: ruby-core
Issue #18969 has been updated by ko1 (Koichi Sasada).
Same as https://bugs.ruby-lang.org/issues/18798 ?
----------------------------------------
Feature #18969: Compare only method definitions for Method#== and UnboundMethod#==
https://bugs.ruby-lang.org/issues/18969#change-98781
* Author: Eregon (Benoit Daloze)
* Status: Open
* Priority: Normal
----------------------------------------
From https://bugs.ruby-lang.org/issues/18751#note-16
During the last dev meeting, @ko1 said Method#== should be "is it the same definition?" and I agree.
In #18751 I did it for zsuper methods (was necessary for compatibility).
But maybe we should do it for all methods.
Currently, Method#== and UnboundMethod#== compare the method definitions, but also (I think, the code is not that clear) on which receiver/class the method was fetched (klass for `klass.instance_method(name)` or `obj` for `obj.method(name)`).
(Maybe it checks the `#owner` too? I'm unsure)
This proposal is to do only the first: compare the method definitions.
So for instance:
```ruby
class A
def foo
end
end
class B < A
end
p A.instance_method(:foo) # => #<UnboundMethod: A#foo() method_eq.rb:2>
p A.instance_method(:foo).owner
p B.instance_method(:foo) # => #<UnboundMethod: B(A)#foo() method_eq.rb:2>
p B.instance_method(:foo).owner
p A.instance_method(:foo) == B.instance_method(:foo) # currently false, with proposal true
p A.new.method(:foo) == B.new.method(:foo) # currently false, with proposal true
# Current workaround needed to compare definitions:
m1, m2 = A.instance_method(:foo), B.instance_method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
m1, m2 = A.new.method(:foo), B.new.method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
```
I think this is the main usage of Method#== and UnboundMethod#==, to compare "is it the same method definition?".
OTOH, if we think this is not good for #== we could add `{Method,UnboundMethod}#same_definition?(other)`. `same_definition?` has the slight advantage that it could be true for `Method#same_definition?(UnboundMethod)` and vice versa.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 4+ messages in thread
* [ruby-core:109601] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#==
2022-08-20 12:05 [ruby-core:109590] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#== Eregon (Benoit Daloze)
2022-08-20 16:21 ` [ruby-core:109600] " ko1 (Koichi Sasada)
@ 2022-08-20 19:45 ` Eregon (Benoit Daloze)
2022-08-20 19:52 ` [ruby-core:109604] " Eregon (Benoit Daloze)
2 siblings, 0 replies; 4+ messages in thread
From: Eregon (Benoit Daloze) @ 2022-08-20 19:45 UTC (permalink / raw
To: ruby-core
Issue #18969 has been updated by Eregon (Benoit Daloze).
Status changed from Open to Closed
@ko1 Indeed, I'll mark this one as duplicate and close it, and I'll add your issue to the dev meeting.
----------------------------------------
Feature #18969: Compare only method definitions for Method#== and UnboundMethod#==
https://bugs.ruby-lang.org/issues/18969#change-98784
* Author: Eregon (Benoit Daloze)
* Status: Closed
* Priority: Normal
----------------------------------------
From https://bugs.ruby-lang.org/issues/18751#note-16
During the last dev meeting, @ko1 said Method#== should be "is it the same definition?" and I agree.
In #18751 I did it for zsuper methods (was necessary for compatibility).
But maybe we should do it for all methods.
Currently, Method#== and UnboundMethod#== compare the method definitions, but also (I think, the code is not that clear) on which receiver/class the method was fetched (klass for `klass.instance_method(name)` or `obj` for `obj.method(name)`).
(Maybe it checks the `#owner` too? I'm unsure)
This proposal is to do only the first: compare the method definitions.
So for instance:
```ruby
class A
def foo
end
end
class B < A
end
p A.instance_method(:foo) # => #<UnboundMethod: A#foo() method_eq.rb:2>
p A.instance_method(:foo).owner
p B.instance_method(:foo) # => #<UnboundMethod: B(A)#foo() method_eq.rb:2>
p B.instance_method(:foo).owner
p A.instance_method(:foo) == B.instance_method(:foo) # currently false, with proposal true
p A.new.method(:foo) == B.new.method(:foo) # currently false, with proposal true
# Current workaround needed to compare definitions:
m1, m2 = A.instance_method(:foo), B.instance_method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
m1, m2 = A.new.method(:foo), B.new.method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
```
I think this is the main usage of Method#== and UnboundMethod#==, to compare "is it the same method definition?".
OTOH, if we think this is not good for #== we could add `{Method,UnboundMethod}#same_definition?(other)`. `same_definition?` has the slight advantage that it could be true for `Method#same_definition?(UnboundMethod)` and vice versa.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 4+ messages in thread
* [ruby-core:109604] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#==
2022-08-20 12:05 [ruby-core:109590] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#== Eregon (Benoit Daloze)
2022-08-20 16:21 ` [ruby-core:109600] " ko1 (Koichi Sasada)
2022-08-20 19:45 ` [ruby-core:109601] " Eregon (Benoit Daloze)
@ 2022-08-20 19:52 ` Eregon (Benoit Daloze)
2 siblings, 0 replies; 4+ messages in thread
From: Eregon (Benoit Daloze) @ 2022-08-20 19:52 UTC (permalink / raw
To: ruby-core
Issue #18969 has been updated by Eregon (Benoit Daloze).
#18798 made me realize the proposed behavior makes sense for UnboundMethod#== but probably less for Method#== which probably should keep checking the receivers are the same.
----------------------------------------
Feature #18969: Compare only method definitions for Method#== and UnboundMethod#==
https://bugs.ruby-lang.org/issues/18969#change-98787
* Author: Eregon (Benoit Daloze)
* Status: Closed
* Priority: Normal
----------------------------------------
From https://bugs.ruby-lang.org/issues/18751#note-16
During the last dev meeting, @ko1 said Method#== should be "is it the same definition?" and I agree.
In #18751 I did it for zsuper methods (was necessary for compatibility).
But maybe we should do it for all methods.
Currently, Method#== and UnboundMethod#== compare the method definitions, but also (I think, the code is not that clear) on which receiver/class the method was fetched (klass for `klass.instance_method(name)` or `obj` for `obj.method(name)`).
(Maybe it checks the `#owner` too? I'm unsure)
This proposal is to do only the first: compare the method definitions.
So for instance:
```ruby
class A
def foo
end
end
class B < A
end
p A.instance_method(:foo) # => #<UnboundMethod: A#foo() method_eq.rb:2>
p A.instance_method(:foo).owner
p B.instance_method(:foo) # => #<UnboundMethod: B(A)#foo() method_eq.rb:2>
p B.instance_method(:foo).owner
p A.instance_method(:foo) == B.instance_method(:foo) # currently false, with proposal true
p A.new.method(:foo) == B.new.method(:foo) # currently false, with proposal true
# Current workaround needed to compare definitions:
m1, m2 = A.instance_method(:foo), B.instance_method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
m1, m2 = A.new.method(:foo), B.new.method(:foo)
p m1.owner.instance_method(m1.name) == m2.owner.instance_method(m2.name) # => true
```
I think this is the main usage of Method#== and UnboundMethod#==, to compare "is it the same method definition?".
OTOH, if we think this is not good for #== we could add `{Method,UnboundMethod}#same_definition?(other)`. `same_definition?` has the slight advantage that it could be true for `Method#same_definition?(UnboundMethod)` and vice versa.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2022-08-20 19:52 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2022-08-20 12:05 [ruby-core:109590] [Ruby master Feature#18969] Compare only method definitions for Method#== and UnboundMethod#== Eregon (Benoit Daloze)
2022-08-20 16:21 ` [ruby-core:109600] " ko1 (Koichi Sasada)
2022-08-20 19:45 ` [ruby-core:109601] " Eregon (Benoit Daloze)
2022-08-20 19:52 ` [ruby-core:109604] " Eregon (Benoit Daloze)
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).