[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 <[e-mail]>
----------------------------------------
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, #<Module:0x19bcd40>, Precision, Numeric, Foo, Comparable, Object, Kernel]
=end



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