From: Yusuke Endoh Date: 2012-02-14T21:30:25+09:00 Subject: [ruby-core:42617] [ruby-trunk - Feature #1586][Rejected] Including a module already present in ancestors should not be ignored Issue #1586 has been updated by Yusuke Endoh. Status changed from Assigned to Rejected I'm rejecting this feature ticket because no progress has been made for a long time. See [ruby-core:42391]. This is indeed a hard issue. There are two approaches to make it consistent: A) prohibit multiple appearances of one module in ancestors B) permit multiple appearances I guess matz prefers A to B, so B will not be admissible. (just my guess, though) The current behavior aims A, but is indeed incomplete. In casual use case, however, module inclusion is used statically, i.e., used when a class is first defined. Thus, no actual problem is caused in practical case, I think. In addition, A will be very hard to implement completely. Even if it is possible, I'm afraid that the behavior will be bug-prone (for both user code and ruby impl), because it means that an already-included module may be later removed from ancestors, unexpectedly. Thus, I think that we can not fix this elegantly and will not change the current behavior. But we might have to do something if there is any *concrete* scenario in that the current behavior causes a trouble. Let us know such a scenario if you have. -- Yusuke Endoh ---------------------------------------- Feature #1586: Including a module already present in ancestors should not be ignored https://bugs.ruby-lang.org/issues/1586 Author: Jeremy Kemper Status: Rejected Priority: Normal Assignee: Yukihiro Matsumoto Category: Target version: ruby -v: ruby 1.8.8dev (2009-03-19 revision 23009) [i386-darwin9.6.2] =begin The scenario: * I include Foo in Numeric to provide #bar * Some other library includes a module in Float to provide #bar * So I include Foo in Float to use my #bar * But including Foo in Float is ignored since it's already in the ancestor chain I think it should be added to the ancestor chain, even if it's already present, since I may want to override some other method earlier in the ancestor chain. # Including a module already included in a superclass is ignored >> module Foo; end => nil >> class Numeric; include Foo; end => Numeric >> Float.ancestors => [Float, Precision, Numeric, Foo, Comparable, Object, Kernel] >> class Float; include Foo; end => Float >> Float.ancestors => [Float, Precision, Numeric, Foo, Comparable, Object, Kernel] # Reversing the order of inclusion works as expected >> module Foo; end => nil >> class Float; include Foo; end => Float >> Float.ancestors => [Float, Foo, Precision, Numeric, Comparable, Object, Kernel] >> class Numeric; include Foo; end => Numeric >> Float.ancestors => [Float, Foo, Precision, Numeric, Foo, Comparable, Object, Kernel] # And so does including a dupe of the existing module in the subclass >> module Foo; end => nil >> class Numeric; include Foo; end => Numeric >> Float.ancestors => [Float, Precision, Numeric, Foo, Comparable, Object, Kernel] >> class Float; include Foo.dup; end => Float >> Float.ancestors => [Float, #, Precision, Numeric, Foo, Comparable, Object, Kernel] =end -- http://bugs.ruby-lang.org/