From: ruby-core@... Date: 2017-11-28T03:54:22+00:00 Subject: [ruby-core:83903] [Ruby trunk Feature#1586] Including a module already present in ancestors should not be ignored Issue #1586 has been updated by marcandre (Marc-Andre Lafortune). matz (Yukihiro Matsumoto) wrote: > So I think this change is good but we need to make it in proper timing. mame (Yusuke Endoh) wrote: > When is proper time? Ruby 3.0? :-) As soon as Nobu can code it? I'll note that we can already `prepend` a module more than once: ``` Base = Class.new Foo = Class.new(Base) M = Module.new; N = M.dup Base.prepend M; Base.include N Foo.prepend M; Foo.include N Foo.ancestors # => [M, Foo, M, Base, N, Object, Kernel, BasicObject] ``` ---------------------------------------- Feature #1586: Including a module already present in ancestors should not be ignored https://bugs.ruby-lang.org/issues/1586#change-67953 * Author: bitsweat (Jeremy Daer) * Status: Assigned * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) * Target version: Next Major ---------------------------------------- =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 ---Files-------------------------------- inclusion.pdf (56.4 KB) -- https://bugs.ruby-lang.org/ Unsubscribe: