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>gt;, 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/