Issue #19573 has been updated by sawa (Tsuyoshi Sawada). I have a little concern about the method name. `self.inherited(subclass)` reads as
`self` is inherited by `subclass`.
Will an analogy work such that `self.singleton_inherited(s_class)` reads something like:
`self` is inherited by `s_class` {in the sense of/from the point of view of/etc.} singleton?
I am not sure. When you have a sequence "foo inherited," it is natural to interpret "foo" as the direct object of "inherit" (in an active sentence). This works fine in case of `self.inherited(subclass)`: "`self` is inherited by `subclass`," or "`subclass` inherits `self`". With `self.singleton_inherited(s_class)`, we still want to say that `self` is the direct object of "inherit", but "singleton" is stuck in between them, which makes it potentially unclear what the direct object is. Perhaps, it is more tempting to read it as
singleton is inherited by `self`, or `self` inherits singleton,
contrary to the intention, unless it is clear that the "singleton" here is meant to be some kind of an adverbial expression along the lines of "{in the sense of/from the point of view of} singleton." I am not sure if that is the case. It may be a good method name, it may be not. I am not sure. On other hand, would it work if `Class#inherited` takes a keyword argument: `foo.inherited(subclass, singleton: true)`, or even go further to let `Class#inherited` be triggered also on singleton class creation? ---------------------------------------- Feature #19573: Add Class#singleton_inherited https://bugs.ruby-lang.org/issues/19573#change-102640 * Author: jeremyevans0 (Jeremy Evans) * Status: Open * Priority: Normal ---------------------------------------- This would be similar to `Class#inherited`, but would be called with singleton classes of instances instead of subclasses. This could be used to warn or raise on singleton class creation, or modify the instance to change behavior, such as allow optimizations when a singleton class does not exist, but allow fallbacks if it does exist. ```ruby c = Class.new do def self.inherited(subclass) p :inherited end def self.singleton_inherited(singleton_class) # could use singleton_class.attached_object for modifying related object p :singleton_inherited end end Class.new(c) # prints :inherited c.new.singleton_class # prints :singleton_inherited ``` This could potentially be an instance method (e.g. `Kernel#singleton_class_created` or `BasicObject#singleton_class_created`) instead of a class method. However, that would not grant any additional flexibility, since per-object behavior first requires creation of a singleton class. If this is accepted, should the method be called for singleton classes created by `Kernel#clone` if the receiver has a singleton class? I think it should, as `Class#inherited` is called for `Class#clone`. -- https://bugs.ruby-lang.org/