Issue #7274 has been updated by matz (Yukihiro Matsumoto). OK, I misunderstood something. In case foo is implemented in Base as in the original example, I admit that it will not cause any serious problem. But I still have small concern. If you are sure foo is implemented in Base, you can retrieve foo from Base (not from Sub), so that you don't have to worry about redefinition. If you are not, the code will be fragile. It's a sign of bad code. Thus, I'd like to ask you why you want to relax? Consistency? Any actual use-case? If there's actual non trivial use-case, I'd say go. Matz. ---------------------------------------- Feature #7274: UnboundMethods should be bindable to any object that is_a?(owner of the UnboundMethod) https://bugs.ruby-lang.org/issues/7274#change-43158 Author: rits (First Last) Status: Rejected Priority: Normal Assignee: matz (Yukihiro Matsumoto) Category: core Target version: next minor =begin as a corollary, (({UnboundMethod}))s referencing the same method name on the same owner, should be equal currently (({UnboundMethod}))s binding is determined by the class via which they were retrieved, not the owner class Base; def foo; end end class Sub < Base; end base_foo = Base.instance_method :foo sub_foo = Sub.instance_method :foo sub_foo.bind(Base.new).call (({sub_foo.owner})) is (({Base})) so there does not seem to be any reason why it's not safe for it to bind to an instance of (({Base})). and there does not seem to be any reason for (({sub_foo})) and (({base_foo})) to be unequal, they both refer to the same method, (({foo})) on (({Base})). =end -- http://bugs.ruby-lang.org/