# Inherited behaviour

**URL:** <https://www.ruby-forum.com/t/inherited-behaviour/136375>\
**Category:** Ruby\
**Created:** [May 1, 2008, 11:21am UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375 "2008-05-01T11:21:33Z")\
**Posts on this page:** 8\
**Page:** 1

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [May 1, 2008, 11:21am UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/1 "2008-05-01T11:21:33Z")

</div>

Folks, would there be any DOWNSIDE to the call to the parents INHERITED  
method being deferred from the start to the end of the definition of  
the subclass?

At the moment if you…

class A  
def self.inherited klass  
end  
end

class B \< A # this is point (1)  
def self.some\_method  
end  
end # this is point (2)

at point (1), the inherited call on A happens.  
Now, what I want to know is… would there be a problem if this was  
deferred to point(2)

if you DID do that, then you could do interesting things inside  
inherited…

class A  
def self.inherited klass  
do\_something\_interesting if klass.respond\_to?(:some\_method)  
end  
end

Just a thought.

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [May 1, 2008, 2:23pm UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/2 "2008-05-01T14:23:08Z")

</div>

Hi –

On Thu, 1 May 2008, Peter Morris wrote:

> class A  
> def self.inherited klass  
> do\_something\_interesting if klass.respond\_to?(:some\_method)  
> end  
> end

It would introduce a kind of strange disjunction between the method  
name and the order of execution 🙂 I don’t think “inherited” would be  
the right name any more. Also, consider this:

module SomeModule  
def x  
end  
end

class A  
def inherited©  
c.extend(SomeModule)  
end  
end

class B \< A  
x  
end

There are definitely things you can and can’t do, given either  
scenario. I think having the inherited hook be triggered upon the  
event of inheritance makes the most sense.

David

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [May 1, 2008, 6:36pm UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/3 "2008-05-01T18:36:26Z")

</div>

Peter Morris wrote:

> class B \< A # this is point (1)  
> def self.some\_method  
> end  
> end # this is point (2)
> 
> at point (1), the inherited call on A happens.  
> Now, what I want to know is… would there be a problem if this was  
> deferred to point(2)

Ruby classes are never closed, so there is no significant point (2),  
just an arbitrary snapshot in the continuing definition of class B.

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [May 1, 2008, 10:21pm UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/4 "2008-05-01T22:21:29Z")

</div>

On May 1, 11:32 am, Joel VanderWerf [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> > end  
> > Ruby classes are never closed, so there is no significant point (2),  
> > just an arbitrary snapshot in the continuing definition of class B.

There’s only one inheritance point for a class, though. That the class  
isn’t closed doesn’t even enter into it. It’s not like you can change  
the inheritance later on. Consider the following:

class B \< A  
# some stuff  
end

class B \< A # reopening with explicit parent, fine  
# more stuff  
end

class B # reopening without parent, fine  
# more stuff  
end

class B \< C # reopening with explicit parent, no good since the  
parent is different  
# more stuff  
end

In this case, the “significant point (2)” would be the first ‘end’ in  
this example, the one immediately following the “some stuff” comment.

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [May 1, 2008, 10:38pm UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/5 "2008-05-01T22:38:01Z")

</div>

Hi –

On Fri, 2 May 2008, Yossef M. wrote:

> > > end
> 
> ```
> # more stuff
> 
> ```
> 
> end
> 
> In this case, the “significant point (2)” would be the first ‘end’ in  
> this example, the one immediately following the “some stuff” comment.

That seems very arbitrary, though, in the sense that the superclass’s  
business with the subclass has no more to do with methods defined the  
first time the class is opened than with any others.

David

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [May 5, 2008, 5:11pm UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/6 "2008-05-05T17:11:25Z")

</div>

On May 1, 3:37 pm, “David A. Black” [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> > > > end # this is point (2)  
> > > > the inheritance later on. Consider the following:
> > 
> > ```
> > # more stuff
> > 
> > ```
> 
> That seems very arbitrary, though, in the sense that the superclass’s  
> Seehttp://www.rubypal.comfor details and updates!  
> It is arbitrary, but it makes sense if the method is called  
> ‘inherited’. Really, I agree that it work the way it does now, when  
> the inheritance actually happens. If something has to happen at a  
> different point, it should be a different callback that does it.

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [October 29, 2008, 8:28am UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/7 "2008-10-29T08:28:54Z")

</div>

Yossef M. wrote:

> On May 1, 3:37 pm, “David A. Black” [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:
> 
> > > > > end # this is point (2)  
> > > > > the inheritance later on. Consider the following:
> > > 
> > > ```
> > > # more stuff
> > > 
> > > ```
> > 
> > That seems very arbitrary, though, in the sense that the superclass’s  
> > Seehttp://www.rubypal.comfor details and updates!  
> > It is arbitrary, but it makes sense if the method is called  
> > ‘inherited’. Really, I agree that it work the way it does now, when  
> > the inheritance actually happens. If something has to happen at a  
> > different point, it should be a different callback that does it.

Hi, I have this situation where it would save me some typing if the  
inherited callback was called after the class was fully defined (with  
all its methods).

is there a way I can get “yeah!” instead of “damn!”?

class A  
def self.inherited(klass)  
p klass.respond\_to?(:my\_method) ? “yeah!” : “damn!”  
end  
end

class B \< A  
def self.my\_method  
end  
end

p “too late!” if B.respond\_to?(:my\_method)

thanks!

---

<div class="post-metadata">

**Author:** ![Peter\_Morris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/p/a8b319/32.png) [@Peter\_Morris](https://www.ruby-forum.com/u/Peter_Morris)\
**Post date:** [October 29, 2008, 1:26pm UTC](https://www.ruby-forum.com/t/inherited-behaviour/136375/8 "2008-10-29T13:26:56Z")

</div>

Macario O. wrote:

> Hi, I have this situation where it would save me some typing if the  
> inherited callback was called after the class was fully defined (with  
> all its methods).

But it’s never “fully defined”, as it can be extended at any time in the  
future. (Or depending on how you look at it, it’s “fully defined” at the  
instant the subclass is created, before any methods are added to it)

> is there a way I can get “yeah!” instead of “damn!”?

class Class  
alias :old\_new :new  
def new(parent = Object, &blk)  
child = old\_new(parent, &blk)  
parent.delayed\_inherited(child) if  
parent.respond\_to?(:delayed\_inherited)  
child  
end  
end

class A  
def self.delayed\_inherited(klass)  
p klass.respond\_to?(:my\_method) ? “yeah!” : “damn!”  
end  
end

B = Class.new(A) do  
def self.my\_method  
end  
end

p “too late!” if B.respond\_to?(:my\_method)

### Or you could just trigger it explicitly:

class Class  
def ok  
return unless superclass.respond\_to?(:delayed\_inherited)  
superclass.delayed\_inherited(self)  
end  
end

class A  
def self.delayed\_inherited(klass)  
p klass.respond\_to?(:my\_method) ? “yeah!” : “damn!”  
end  
end

class B \< A  
def self.my\_method  
end  
ok  
end

p “too late!” if B.respond\_to?(:my\_method)

### That’s only two characters to type for each class definition 🙂