* [ruby-core:105796] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
@ 2021-10-26 2:21 ` shugo (Shugo Maeda)
2021-10-26 19:12 ` [ruby-core:105816] " Eregon (Benoit Daloze)
` (9 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: shugo (Shugo Maeda) @ 2021-10-26 2:21 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by shugo (Shugo Maeda).
Status changed from Open to Assigned
Matz, can I add Module#defined_refinements?
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94315
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p Module.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in Module.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:105816] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
2021-10-26 2:21 ` [ruby-core:105796] [Ruby master Feature#12737] Module#defined_refinements shugo (Shugo Maeda)
@ 2021-10-26 19:12 ` Eregon (Benoit Daloze)
2021-11-16 4:43 ` [ruby-core:106076] " shugo (Shugo Maeda)
` (8 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: Eregon (Benoit Daloze) @ 2021-10-26 19:12 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by Eregon (Benoit Daloze).
Should the code in the description be `p M.defined_refinements`?
I'm not sure to understand the use case, isn't `using M` doing the same as that `for`?
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94337
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p Module.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in Module.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106076] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
2021-10-26 2:21 ` [ruby-core:105796] [Ruby master Feature#12737] Module#defined_refinements shugo (Shugo Maeda)
2021-10-26 19:12 ` [ruby-core:105816] " Eregon (Benoit Daloze)
@ 2021-11-16 4:43 ` shugo (Shugo Maeda)
2021-11-16 12:39 ` [ruby-core:106088] " Eregon (Benoit Daloze)
` (7 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: shugo (Shugo Maeda) @ 2021-11-16 4:43 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by shugo (Shugo Maeda).
Eregon (Benoit Daloze) wrote in #note-4:
> Should the code in the description be `p M.defined_refinements`?
Yes.
> I'm not sure to understand the use case, isn't `using M` doing the same as that `for`?
Forget the following example. It was not a good idea.
```
for klass, refinement in Module.defined_refinements
klass.prepend(refinement)
end
```
Module#defined_refinements is a reflection API for debugging purposes.
You can get a similar result of Module.used_refinements using Module.use_modules and Module#defined_refinements except that Module.used_refinements only returns refinements defined at the time when modules are used.
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94665
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p Module.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in Module.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106088] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (2 preceding siblings ...)
2021-11-16 4:43 ` [ruby-core:106076] " shugo (Shugo Maeda)
@ 2021-11-16 12:39 ` Eregon (Benoit Daloze)
2021-11-18 5:55 ` [ruby-core:106115] " shugo (Shugo Maeda)
` (6 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: Eregon (Benoit Daloze) @ 2021-11-16 12:39 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by Eregon (Benoit Daloze).
Ah, so it's to list the refinements (instance of Refinement) under a "namespace module" like `M`, without needing `using`.
I'm unsure of use cases besides debugging, but I think it's useful to add.
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94679
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p Module.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in Module.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106115] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (3 preceding siblings ...)
2021-11-16 12:39 ` [ruby-core:106088] " Eregon (Benoit Daloze)
@ 2021-11-18 5:55 ` shugo (Shugo Maeda)
2021-11-18 9:40 ` [ruby-core:106128] " Eregon (Benoit Daloze)
` (5 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: shugo (Shugo Maeda) @ 2021-11-18 5:55 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by shugo (Shugo Maeda).
Considerations raised by Matz at the developers meeting on 2021-11-18:
1. Is the name **defined**_refinements appropriate?
other proposals:
* configured_refinements (by tenderlove)
* refinements
* consistent with Module#constants
* contained_refinements
2. Should the return value be an Array instead of a Hash?
pros:
* consistent with Module.used_refinements
cons:
* A new API like Refinement#refined_class (or target_class) is needed to know the refined class.
* `M.defined_refinements.find { |r| r.refined_class == Integer }` is longer than `M.defined_refinements[Integer]`.
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94712
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106128] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (4 preceding siblings ...)
2021-11-18 5:55 ` [ruby-core:106115] " shugo (Shugo Maeda)
@ 2021-11-18 9:40 ` Eregon (Benoit Daloze)
2021-11-19 2:01 ` [ruby-core:106164] " shugo (Shugo Maeda)
` (4 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: Eregon (Benoit Daloze) @ 2021-11-18 9:40 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by Eregon (Benoit Daloze).
Module#refinements seems nice and straightforward.
I think `Refinement#refined_class` is useful in any case, +1 to add that.
I slightly prefer the array variant.
Since this would be mostly used for debugging, there might not be any need to filter in many cases, i.e., the Refinement#inspect output already shows the refined_class's name, so `p M.refinements` seems typical usage (and the Hash for that case would just be more verbose).
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94726
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106164] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (5 preceding siblings ...)
2021-11-18 9:40 ` [ruby-core:106128] " Eregon (Benoit Daloze)
@ 2021-11-19 2:01 ` shugo (Shugo Maeda)
2021-12-09 7:10 ` [ruby-core:106571] " matz (Yukihiro Matsumoto)
` (3 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: shugo (Shugo Maeda) @ 2021-11-19 2:01 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by shugo (Shugo Maeda).
Eregon (Benoit Daloze) wrote in #note-10:
> Module#refinements seems nice and straightforward.
I prefer Module#refinements too.
> I slightly prefer the array variant.
> Since this would be mostly used for debugging, there might not be any need to filter in many cases, i.e., the Refinement#inspect output already shows the refined_class's name, so `p M.refinements` seems typical usage (and the Hash for that case would just be more verbose).
The array variant is OK for me if Refinement#refined_class will be introduced.
Another use case is testing of Refinements themselves:
```
m = Module.new {
refine Integer do
....
end
refine String do
...
end
}
refinements = m.refinements
assert_something ..., refinements[Integer]
assert_something ..., refinements[String]
```
However, I may be the only user, so it's not so important.
If there are more use cases, Module#refinement_get can be added in the future.
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-94767
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106571] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (6 preceding siblings ...)
2021-11-19 2:01 ` [ruby-core:106164] " shugo (Shugo Maeda)
@ 2021-12-09 7:10 ` matz (Yukihiro Matsumoto)
2021-12-10 4:43 ` [ruby-core:106612] " shugo (Shugo Maeda)
` (2 subsequent siblings)
10 siblings, 0 replies; 11+ messages in thread
From: matz (Yukihiro Matsumoto) @ 2021-12-09 7:10 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by matz (Yukihiro Matsumoto).
OK, accepted. After 3.1, you can introduce:
* Module#refinements
* Refinment#refined_class
Matz.
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-95233
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:106612] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (7 preceding siblings ...)
2021-12-09 7:10 ` [ruby-core:106571] " matz (Yukihiro Matsumoto)
@ 2021-12-10 4:43 ` shugo (Shugo Maeda)
2023-06-06 12:00 ` [ruby-core:113777] " Eregon (Benoit Daloze) via ruby-core
2023-06-06 12:37 ` [ruby-core:113778] " shugo (Shugo Maeda) via ruby-core
10 siblings, 0 replies; 11+ messages in thread
From: shugo (Shugo Maeda) @ 2021-12-10 4:43 UTC (permalink / raw)
To: ruby-core
Issue #12737 has been updated by shugo (Shugo Maeda).
Assignee set to shugo (Shugo Maeda)
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-95281
* Author: shugo (Shugo Maeda)
* Status: Assigned
* Priority: Normal
* Assignee: shugo (Shugo Maeda)
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:113777] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (8 preceding siblings ...)
2021-12-10 4:43 ` [ruby-core:106612] " shugo (Shugo Maeda)
@ 2023-06-06 12:00 ` Eregon (Benoit Daloze) via ruby-core
2023-06-06 12:37 ` [ruby-core:113778] " shugo (Shugo Maeda) via ruby-core
10 siblings, 0 replies; 11+ messages in thread
From: Eregon (Benoit Daloze) via ruby-core @ 2023-06-06 12:00 UTC (permalink / raw)
To: ruby-core; +Cc: Eregon (Benoit Daloze)
Issue #12737 has been updated by Eregon (Benoit Daloze).
`Refinement#refined_class` is a bit strange given it can return a module.
How about adding `Refinement#refined_module` as an alias for clarity?
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-103426
* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: shugo (Shugo Maeda)
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
______________________________________________
ruby-core mailing list -- ruby-core@ml.ruby-lang.org
To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread
* [ruby-core:113778] [Ruby master Feature#12737] Module#defined_refinements
[not found] <redmine.issue-12737.20160908053811.12@ruby-lang.org>
` (9 preceding siblings ...)
2023-06-06 12:00 ` [ruby-core:113777] " Eregon (Benoit Daloze) via ruby-core
@ 2023-06-06 12:37 ` shugo (Shugo Maeda) via ruby-core
10 siblings, 0 replies; 11+ messages in thread
From: shugo (Shugo Maeda) via ruby-core @ 2023-06-06 12:37 UTC (permalink / raw)
To: ruby-core; +Cc: shugo (Shugo Maeda)
Issue #12737 has been updated by shugo (Shugo Maeda).
Eregon (Benoit Daloze) wrote in #note-15:
> `Refinement#refined_class` is a bit strange given it can return a module.
> How about adding `Refinement#refined_module` as an alias for clarity?
I'm for it, but it may be better to create another issue.
----------------------------------------
Feature #12737: Module#defined_refinements
https://bugs.ruby-lang.org/issues/12737#change-103427
* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: shugo (Shugo Maeda)
----------------------------------------
How about to provide Module#defined_refinements, which returns the refinements defined in the receiver as a Hash, as follows:
```
module M
refine String do
$M_String = self
end
refine Integer do
$M_Integer = self
end
end
p M.defined_refinements #=> {String => $M_String, Integer => $M_Integer}
```
By `Module#defined_refinements`, you can activate refinements globally:
```
for klass, refinement in M.defined_refinements
klass.prepend(refinement)
end
```
--
https://bugs.ruby-lang.org/
______________________________________________
ruby-core mailing list -- ruby-core@ml.ruby-lang.org
To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/
^ permalink raw reply [flat|nested] 11+ messages in thread