[ruby-core:112852] [Ruby master Feature#19520] Support for `Module.new(name)` and `Class.new(superclass, name)`.

10 Mar 2023

      Issue #19520 has been updated by ioquatix (Samuel Williams).
...
there won't be a way to ever get the actual name of that module, regardless of it was anonymous or named. It would forever return the name that the user specified.
That's not how the proposal here works. One you assign a permanent name, it replaces any fake/temporary name.

```ruby
m = Module.new("fake")
=> fake

m.name
=> "fake"

M = m
=> M

m.name
=> "M"

Module.instance_method(:name).bind_call(m)
=> "M"
```
...
That's fine, this is easy to recognize there an anonymous module in there, there is no confusion.
Unlike a Foo::Bar name with this feature and yet never having a Foo constant defined on Object.
Don't live code reloading systems work exactly like this, creating a whole bunch of "orphaned" constants?

----------------------------------------
Feature #19520: Support for `Module.new(name)` and `Class.new(superclass, name)`.
https://bugs.ruby-lang.org/issues/19520#change-102364

* Author: ioquatix (Samuel Williams)
* Status: Open
* Priority: Normal
----------------------------------------
See <https://bugs.ruby-lang.org/issues/19450> for previous discussion and motivation.

[This proposal](https://github.com/ruby/ruby/pull/7376) introduces the `name` parameter to `Class.new` and `Module.new`:

```ruby
Class.new(superclass, name)
Module.new(name)
```

As a slight change, we could use keyword arguments instead.

## Example usage

The current Ruby test suite has code which shows the usefulness of this new method:

```ruby
  def labeled_module(name, &block)
    Module.new do
      singleton_class.class_eval {
        define_method(:to_s) {name}
        alias inspect to_s
        alias name to_s
      }
      class_eval(&block) if block
    end
  end
  module_function :labeled_module

  def labeled_class(name, superclass = Object, &block)
    Class.new(superclass) do
      singleton_class.class_eval {
        define_method(:to_s) {name}
        alias inspect to_s
        alias name to_s
      }
      class_eval(&block) if block
    end
  end
  module_function :labeled_class
```

The updated code would look like this:

```ruby
  def labeled_module(name, &block)
    Module.new(name, &block)
  end

  def labeled_class(name, superclass = Object, &block)
    Class.new(superclass, name, &block)
  end
  module_function :labeled_class
```

-- 
https://bugs.ruby-lang.org/