Project

General

Profile

Feature #11927

Updated by sawa (Tsuyoshi Sawada) about 2 months ago

Currently, `Module#include` and `Module#prepend` return the receiver, regardless of whether the ancestor chain has been modified. It is not straightforward to know whether it actually had effect. 

 ~~~ruby 
 module A; end 
 module B; end 
 A.include B # => A 
 A.ancestors # => [A, B] 
 A.prepend B # => A 
 A.ancestors # => [A, B] 
 ~~~ 

 I propose that, when `Module#include` and `Module#prepend` have no effect, they should either: 

 (1) return `nil` 
 (2) return `false`, or 
 (3) raise an exception 

 This is similar to `Kernel#require`, which returns `false` when it has no effect. To make it parallel with `Kernel#require`, it might be even better to return `true` when `Module#include` and `Module#prepend` have effect, and `false` otherwise. It makes no sense to return the receiver because that is known. 

 Some relevant cases with expectations are: 

 * prepend after include 

 ~~~ruby 
 module A; end 
 module B; end 
 A.include B # => A/true 
 A.prepend B # => nil/false/exception 
 ~~~ 


 * include after prepend 

 ~~~ruby 
 module A; end 
 module B; end 
 A.prepend A.include B # => A/true 
 A.include A.prepend B # => nil/false/exception 
 ~~~ 

 * include/prepend after include/include at superclass 

 ~~~ruby 
 class A; end 
 module B; end 
 A.include M # => A/true 
 class B < A; end 
 B.include M # => nil/false/exception 
 ~~~

Back