Issue #19742 has been updated by ioquatix (Samuel Williams). There is another formulation of the opposite of "anonymous" which could be the following: ```ruby class Module def permanent? Object.const_get(self.name).equal?(self) end end ``` This would be true if the object is reachable by the name it says it is. It's a little slower, but perhaps a better approach. We might be able to optimise it internally if the object/module know's it's parent namespace and name within that namespace (i.e. don't need to use `const_get`). So it might be true that `anonymous?` and `permanent?` are related but different. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103625 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). Permanent is already a word used in the Ruby documentation and implementation. I agree it might not be clear, but it's already established when talking about "class paths" and names. if we introduce a new name, we should have a strong reason to do so. Out of the two, I'd say `permanent?` as proposed has a stronger meaning than `anonymous?` as in some cases both can be false but in that case, `permanent?` is correct while `anonymous?` is probably at best misleading and at worst wrong. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103637 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). The concepts are discussed in the code, but they shouldn't be assumed as canonical, IMHO. ```c /** * Returns +classpath+ of _klass_, if it is named, or +nil+ for * anonymous +class+/+module+. A named +classpath+ may contain * an anonymous component, but the last component is guaranteed * to not be anonymous. <code>*permanent</code> is set to 1 * if +classpath+ has no anonymous components. There is no builtin * Ruby level APIs that can change a permanent +classpath+. */ static VALUE classname(VALUE klass, bool *permanent) ``` A class/module that is assigned a name via `set_temporary_name` may still be anonymous, so I believe the above comment needs to be updated. In the code, when something is not `permanent`, a `temporary` class path may be generated: ```c static VALUE make_temporary_path(VALUE obj, VALUE klass) { VALUE path; switch (klass) { case Qnil: path = rb_sprintf("#<Class:%p>", (void*)obj); break; case Qfalse: path = rb_sprintf("#<Module:%p>", (void*)obj); break; default: path = rb_sprintf("#<%"PRIsVALUE":%p>", klass, (void*)obj); break; } OBJ_FREEZE(path); return path; } ``` To clarify, the documentation states that when `mod.name == nil`, the `mod` is anonymous. But it does not state that when `mod.name =! nil`, the module is permanent AFAICT. In any case, we should probably clarify this in the documentation. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103639 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). Just because `name == nil` implies it's anonymous, does not mean that anonymous implies that `name == nil`. In fact, we don't have any `anonymous?` implementation yet to define this behaviour. I don't know if the documentation clarifies this or not, but I don't recall seeing it clearly outlined anywhere. If anything, I think this issue is a good place to figure out what we want, and then add clear and canonical documentation (as well as specs). Until my previous PR `set_temporary_name`, which includes a discussion of `permanent`, I don't think there was any user facing documentation, but the implementation is clear on the behaviour. I'd be okay with changing this documentation if we want to clarify some aspects of it (we still have until Ruby 3.3 release which is months away). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103641 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). The documentation for `Module#name` says: So, _if_ the module is anonymous, _then_ the name is `nil`. Logically, that does not rule out as a possibility that a non-anonymous module may also have a `nil` name, but I believe you take that for granted. If you are not anonymous, you have a name (ie, a value that is not `nil`), that is the common meaning of something not being anonymous. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103643 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). Anyone can do the following: ```ruby my_module = Module.new do def self.name "Hello World" end end ``` Is that module anonymous or not? ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103645 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). I don't understand, is this correct or not? ```ruby class Module def anonymous? name == '' || name.nil? end end Module.new.anonymous? # => true my_module = Module.new do def self.name "Hello World" end end my_module.anonymous? # => false ``` ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103647 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). Should setting a temporary name make a module not anonymous? I found the following use cases in Rails: ```ruby unless controller_class.anonymous? controller_class.name.delete_suffix("Controller").underscore end ``` ```ruby def self.kind @kind ||= name.split("::").last.underscore.chomp("_validator").to_sym unless anonymous? end ``` ```ruby def self.controller_name @controller_name ||= (name.demodulize.delete_suffix("Controller").underscore unless anonymous?) end ``` ```ruby def controller_path @controller_path ||= name.delete_suffix("Controller").underscore unless anonymous? end ``` ```ruby def mailer_name @mailer_name ||= anonymous? ? "anonymous" : name.underscore end ``` So, I think the usage of anonymous is already ossified by Rails, even if I disagree. To me, anonymous means it cannot be named, but there is a difference between "proper noun" and "common noun". If you refer to a "person", the person does not have a proper name, they are anonymous. If you refer to "Samuel", you are referring to a specific person, which is not anonymous. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103650 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). I'm not that different, except Anonymous to me means you don't have a name [that resolves to self]. If the module has a name that resolves to itself, it is not anonymous. I would say a lot of the rails code should be rewritten just to check `name` itself, e.g. ``` @mailer_name ||= anonymous? ? "anonymous" : name.underscore # becomes @mailer_name ||= name&.underscore || "anonymous" @controller_name ||= (name.demodulize.delete_suffix("Controller").underscore unless anonymous?) # becomes @controller_name ||= (name ? name.demodulize.delete_suffix("Controller").underscore : nil) ``` I think this is much more direct and I don't think Rails should monkey patch Module in this way. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103652 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). @janosch-x agreed, in Zeitwerk I do my best at [reaching the original `Module#name`](https://github.com/fxn/zeitwerk/blob/main/lib/zeitwerk/real_mod_name.rb) because of that. @ioquatix yeah, I understand your point of view. However, we disagree due to two reasons: The first one is that Ruby docs (today) agree with my definition: If a module is anonymous, then its name is `nil`. If `mod.anonymous?` returned true and `mod.name` was not `nil`, we'd violate existing Ruby semantics. The second one is more conceptual: once a name is set, its relationship with storage in the Ruby model is non-existent. You cannot assume or expect anything, because Ruby semantics decouple names and storage. A name, to me, is a string that was once set according to some rules. From then on, it is a mere string. So, I believe trying to mix "anonymous" in between name and storage does not go in the right direction, `reachable_from_its_name?` would be more aligned (not a proposal, just to illustrate my point). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103654 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). I used the word "semantics" because the docs use the English word "anonymous", which is not formal, but would be surprising that `anonymous?` does not behave like like what "anonymous" says today. Yes, but the other direction is "if the name is `nil`, then the module is anonymous". But this is not what we are discussing right? We are discussing if an anonymous module can have a name that is not `nil`. To see that is not possible, you need the arrow in the docs. I personally believe it is fine, even expected, that `name` returns the temporary name. Because that is what it does when implicitly set by Ruby today, and because, well, it is the name at this point in time. It may change, variable vs constant. Hey let me say explicitly that I am participating in the discussion to contribute to it, but Ruby core are who define how the language evolves. So, given we come from different angles that won't reconcile, whatever core decides is going to be OK for me :). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103656 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). @ioquatix oh wait, we might have two questions in our minds. I am like: Can a module whose `mod.name` is not `nil` be `anonymous?`. Answer is, if we want to agree with the current docs, it cannot be, because `Module#name` has to return `nil` for anonymous modules. Then, I guess you had in mind the definition of `Module#anonymous?`. That needs an "iff" indeed. However, if you have to define, then making that condition an "iff" could not be controversial, it is the natural extension to me. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103658 * 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/

Issue #19742 has been updated by Eregon (Benoit Daloze). Eregon (Benoit Daloze) wrote in #note-27: It would mean on `remove_const` and on `const_set(name, v)` when there was already a constant `name`, to change the name of the old constant if it is a module. And also do so recursively for any constant in that module, i.e., mirroring what we do when we name a module, it also names all module constant of that module. Then I think we could finally trust without exception that a non-anonymous `Module#name` is a valid way to reach that Module. That would be great. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-103661 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). We can consider introducing the PR unchanged, it depends on `permanent_classpath` which is an internal implementation detail. If we fix `const_set` and `remove_const` to deal with changing class names, `anonymous?` will reflect that change, since itself it is not making any determination and rather just returning the existing state that Ruby knows about. ```c VALUE rb_mod_anonymous_p(VALUE mod) { return RBOOL(!RCLASS_EXT(mod)->permanent_classpath); } ``` I also think we should consider `Module#permanent?` as described above - that the current name reflects the valid constant path for `self`. However, I agree, re-assignment can cause significant confusion. I am okay with the first assignment being considered special. Certainly that's the case today. After the first assignment, a module is considered permanent. If that binding is removed, e.g. `remove_const`, we could mark that as such. Rebinding a constant to a new constant path could reset the permanent name. However, I feel like that should be solved outside the scope of this PR. So, in order to keep things focused, are there any changes we'd want to make to the above implementation? Alternatively, we could consider: ```c VALUE rb_mod_permanent_p(VALUE mod) { return RBOOL(RCLASS_EXT(mod)->permanent_classpath); } ``` However, I believe we'd want to follow up with another PR to correctly manipulate `permanent_classpath` to make more sense on `remove_const` et al. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-104403 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). @ko1 I think that is a good direction, because with the introduction of temporary names as a blessed concept with API and all, I believe there are several matching APIs that may arise. One proposal could be: ``` Module#name -> as it is today Module#temporary_name -> there is a temporary name or nil Module#permanent_name -> there is a permanent name or nil Module#anonymous? -> both temporary and permanent names are nil ``` For example, edges case that test how do we think about this: ``` m = Module.new m.name #=> nil m.temporary_name #=> nil m.permanent_name #=> nil m.anonymous? #=> true m::C = Class.new m::C.name #=> "#<Module:0x0000000102cd4620>::C" m::C.temporary_name #=> "#<Module:0x0000000102cd4620>::C" m::C.permanent_name #=> nil m::C.anonymous? #=> false M = m m::C.name #=> "M::C" m::C.temporary_name #=> nil m::C.permanent_name #=> "M::C" m::C.anonymous? #=> false ``` ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106245 * 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/

Issue #19742 has been updated by Eregon (Benoit Daloze). Agreed, `anonymous?` seems not well defined for the temporary name case. In fact I would think of `anonymous?` as `!fully_named` and indeed for the anecdote TruffleRuby already has this meaning for anonymous [internally](https://github.com/oracle/truffleruby/blob/1f80340cfdfb46bb9877…. Adding `Module#permanent_name` seems potentially useful. Maybe `Module#temporary_name` too, although if there is `Module#permanent_name` it's the same as `mod.name unless mod.permanent_name`. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106262 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). @Dan0042 yes, there are different points of view expressed, and at some point Rails core will take one direction or another. In my personal proposal, none of the objects are `anonymous?`, because, for me, a temporary name is name. And a permanent name is a name too. If you have a name, you are not anonymous. (@ioquatix had a different point of view.) The last of your examples is important. In Ruby "permanent name" and "being reachable through the contant path" are orthogonal concepts. Once the permanent name is set, there is no public API to change it. It is frozen, and what happens to the perhaps dozen places where the object was stored is irrelevant. The point of `anonymous?` is to have a predicate that expresses `name.nil?` with more concision. If you grep the Rails project, you'll see it used in a bunch of places (it is defined by Active Support). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106264 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). @Dan0042 right, it could be the case that in Rails anything autoloadable has a permanent name and that has made the predicate sufficient in practice after 3.0. I introduced that predicate myself back in 2010 because you got an empty string in 1.8 and `nil` in 1.9, so `anonymous?` at the same time had meaning and was portable. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106271 * 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/

Issue #19742 has been updated by jeremyevans0 (Jeremy Evans). I'm against `Module#anonymous?`, because it's ambiguous. I would expect modules with temporary and not permanent names to be anonymous. If you could never refer to module by absolute constant reference, I would expect it to be should be considered anonymous, even if it has a temporary name. However, taken literally, `anonymous` means no name at all, so I can certainly understand arguments that any name should mean `anonymous?` returns false. So `permanent_name` makes more sense to me, as it is less ambiguous. For Rails, `permanent_name&.underscore` seems better than `name.underscore unless anonymous?`. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106273 * 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/

Issue #19742 has been updated by ioquatix (Samuel Williams). I think we can assume this is a fair definition, but I'd like to confirm it with @matz: ```ruby class Module def permanent? if name = self.name Object.const_get(self.name).equal?(self) end rescue NameError false end def anonymous? !permanent? end end ``` However, alternatively, we could defer to whether a class has (or had) a permanent name. The problem is, they are subtly different. The former (example) is quite a robust definition, while the latter (depending on whether a permanent name has or was assigned) is more prone to edge cases (like `const_remove` as discussed). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106276 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). Same. The name is called "permanent" because it does not change, the predicate above would be `reachable_through_its_name?`. But then, the Ruby language does no have any expectation about the name of classes and modules. If there was some, it would be present and enforced by the language. The name is an attribute of class and module objects, a string, and that is pretty much it. To me, `X = Module.new` and `Y = String.new` are essentially the same. It is true that the first one has a side-effect, but other than that this is storage and objects, and those are orthogonal. You don't even have "namespaces", a module does not have a namespace. A module is an object and can be stored in 7 constants and 4 variables. In Ruby, class and module objects have constants and that is all. It's a pretty weak model in that sense (meaning, you cannot derive much from it). ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106286 * 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/

Issue #19742 has been updated by matz (Yukihiro Matsumoto). First, given the existence of the Module#set_temporary_name method as well, it seems somewhat confusing what the name of this method implies. So, it may be necessary to first clarify what this method really wants to accomplish. In general, in Ruby, the referenced object does not know information about the referencing object (or variables/constants). Class names are an exception, but we recognize that they are for convenience purposes only and are not essential information. The proposed method would have a greater impact than OP thinks, since it would make the ability to retain this class name essential information in Ruby. So currently, I am not positive for adding the method (not regarding the name issue). Matz. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-106316 * 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/

Issue #19742 has been updated by fxn (Xavier Noria). A KISS version of the above is to provide `permanent_name?` only, since the other two can be derived with the help `mod.name.nil?`, and I suspect that there are not a lot of cases in which you need to know if the name is exactly temporary. ---------------------------------------- Feature #19742: Introduce `Module#anonymous?` https://bugs.ruby-lang.org/issues/19742#change-107189 * Author: ioquatix (Samuel Williams) * Status: Open ---------------------------------------- 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/