Issue #19742 has been updated by fxn (Xavier Noria). ❤️ for `anonymous?`. Regarding the broader topic, the fundamental thing to discuss is whether permanent class names and constants should have any more coupling after initial constant assignment (when the name becomes permanent). Because, today, as you know, they don't. That is, once a first constant assignment is done, class and module objects are like any other Ruby object, where `name` is just an attribute. You can do with them object whatever you want, store them wherever you want, that storage can be reassigned, etc. They are no different than `Object.new`. By the same argument, class and module objects do not belong to a namespace. Constants do, different. For example, in ancestor chains you store module objects. They are objects, whether they are reachable via a constant at any point in time is irrelevant. If you remove the original constant, the object is still there. Because storage and objects are orthogonal concepts in Ruby. Another example ``` klass = User user = User.new User = 1 user.class.equal?(klass) # => true user.class.name # => 'User' ``` So... coupling the name to storage would be an important change. However, if coupled to the original constant removal, it would be symmetrical, it could make sense (assuming any change in the original constant path triggers the logic). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103624 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal ---------------------------------------- As a follow-on <from https://bugs.ruby-lang.org/issues/19521>, I'd like propose we introduce `Module#anonymous?`. In some situations, like logging/formatting, serialisation/deserialization, debugging or meta-programming, we might like to know if a class is a proper constant or not. However, this brings about some other issues which might need to be discussed. After assigning a constant, then removing it, the internal state of Ruby still believes that the class name is permanent, even thought it's no longer true. e.g. ``` m = Module.new m.anonymous? # true M = m m.anonyomous # false Object.send(:remove_const, :M) M # uninitialized constant M (NameError) m.anonymous? # false ``` Because RCLASS data structure is not updated after the constant is removed, internally the state still has a "permanent class name". I want to use this proposal to discuss this issue and whether there is anything we should do about such behaviour (or even if it's desirable). Proposed PR: https://github.com/ruby/ruby/pull/7966 cc @fxn -- https://bugs.ruby-lang.org/