[ruby-core:113369] [Ruby master Feature#19520] Support for `Module.new(name)` and `Class.new(superclass, name)`.
From:
"ioquatix (Samuel Williams) via ruby-core" <ruby-core@...>
Date:
2023-04-27 21:49:37 UTC
List:
ruby-core #113369
Issue #19520 has been updated by ioquatix (Samuel Williams).
The difference between a dynamically defined `inspect` which can do anything vs `Module#name` which is cached are significant.
I was now just writing a native Ruby extension, where I wanted a custom `rb_inspect` output. The default code for `rb_inspect` actually invokes `rb_class_name`.
```c
static VALUE
rb_obj_inspect(VALUE obj)
{
if (rb_ivar_count(obj) > 0) {
VALUE str;
VALUE c = rb_class_name(CLASS_OF(obj));
str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj);
return rb_exec_recursive(inspect_obj, obj, str);
}
else {
return rb_any_to_s(obj);
}
}
```
While we in theory can change this to:
```c
VALUE c = rb_inspect(CLASS_OF(obj));
```
which is in line with your (@Dan0042) proposal, I wonder how many existing code in other places would also be copying this or using `rb_class_name`.
You'd probably need to change the implementation of `rb_class_name` to call `rb_inspect`... which just seems like something that would cause regressions/issues to me.
This isn't just used in `NoMethodError`... Lots of tools report the class as part of an error or even as part of the normal execution (e.g. job class serialization, IRB, etc).
----------------------------------------
Feature #19520: Support for `Module.new(name)` and `Class.new(superclass, name)`.
https://bugs.ruby-lang.org/issues/19520#change-102935
* 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/
______________________________________________
ruby-core mailing list -- [email protected]
To unsubscribe send an email to [email protected]
ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/