December 2022 - ruby-core - ml.ruby-lang.org

[ruby-core:111390] [Ruby master Feature#17097] `map_min`, `map_max`
by baweaver (Brandon Weaver) 23 Dec '22

23 Dec '22

Issue #17097 has been updated by baweaver (Brandon Weaver). For the sake of naming conventions I would personally lean towards `map_max` to match methods like `filter_map`, and while this does not necessarily extend to _all_ Enumerable methods I would wonder if there's another conversation later to be had about composite Enumerable methods. On this particular ticket though I believe that the use-case is common enough, and in many cases may be what the developer intends. ---------------------------------------- Feature #17097: `map_min`, `map_max` https://bugs.ruby-lang.org/issues/17097#change-100765 * Author: sawa (Tsuyoshi Sawada) * Status: Open * Priority: Normal ---------------------------------------- `min`, `min_by`, `max`, `max_by` return the element that leads to the minimum or the maximum value, but I think it is as, or even more, frequent that we are interested in the minimum or the maximum value itself rather than the element. For example, to get the length of the longest string in an array, we do: ```ruby %w[aa b cccc dd].max_by(&:length).length # => 4 %w[aa b cccc dd].map(&:length).max # => 4 ``` I propose to have methods that return the minimum or the maximum value. Temporarily calling them `map_min`, `map_max`, they should work like this: ```ruby %w[aa b cccc dd].map_max(&:length) # => 4 ``` `map_min`, `map_max` are implementation-centered names, so perhaps better names should replace them, just like `yield_self` was replaced by `then`. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111389] [Ruby master Bug#19113] Inconsistency in retention of compare_by_identity flag in Hash methods
by matz (Yukihiro Matsumoto) 23 Dec '22

23 Dec '22

Issue #19113 has been updated by matz (Yukihiro Matsumoto). I agree with @jeremyevans0 too. Matz. ---------------------------------------- Bug #19113: Inconsistency in retention of compare_by_identity flag in Hash methods https://bugs.ruby-lang.org/issues/19113#change-100764 * Author: jeremyevans0 (Jeremy Evans) * Status: Open * Priority: Normal * ruby -v: ruby 3.2.0dev (2022-11-07T17:29:28Z master 9001e53e68) [x86_64-openbsd7.2] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- `Hash.[]` and `Hash.ruby2_keywords_hash` retain the compare_by_identity flag for non-empty hashes, but do not retain it for empty hashes: ```ruby hs = [{}.compare_by_identity, {:a=>1}.compare_by_identity] hs.map{|h| Hash[h].compare_by_identity?} # => [false, true] hs.map{|h| Hash.ruby2_keywords_hash(h).compare_by_identity?} # => [false, true] ``` This inconsistency seems like a bug. `Hash#compact` always drops the compare_by_identity flag, but it is documented as returning a copy of self, implying the compare_by_identity flag is kept (since #dup and #clone retain the flag). ```ruby {}.compare_by_identity.compact.compare_by_identity? # => false ``` I'm not sure whether is a bug, because it is consistent, but I think retaining the flag makes more sense. I'll try to work on a fix for both of these issues tomorrow. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111388] [Ruby master Bug#11064] #singleton_methods for objects with special singleton_class returns an empty array
by matz (Yukihiro Matsumoto) 23 Dec '22

23 Dec '22

Issue #11064 has been updated by matz (Yukihiro Matsumoto). @sawa Singleton classes are in principle only accessed using the `singleton_class` method or the singleton class notation. Implementation wise, FL_SINGLETON is set for singleton classes. Neither is true for NilClass (nor FalseClass nor TrueClass). Matz. ---------------------------------------- Bug #11064: #singleton_methods for objects with special singleton_class returns an empty array https://bugs.ruby-lang.org/issues/11064#change-100763 * Author: rbjl (Jan Lelis) * Status: Open * Priority: Normal * ruby -v: ruby 2.2.1p85 (2015-02-26 revision 49769) [x86_64-linux] * Backport: 2.0.0: UNKNOWN, 2.1: UNKNOWN, 2.2: UNKNOWN ---------------------------------------- ~~~ def nil.bla 42 end # works nil.bla #=> 42 nil.singleton_method(:bla) #=> #<Method: NilClass#bla> NilClass.instance_methods.include? :bla #=> true # does not work nil.singleton_methods #=> [] ~~~ -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111387] [Ruby master Feature#17097] `map_min`, `map_max`
by jnchito (Junichi Ito) 23 Dec '22

23 Dec '22

Issue #17097 has been updated by jnchito (Junichi Ito). `max_of` method is very elegant! I really want the Ruby version of this method. For example, I need to write `column_width = @ls_files.map { |ls_file| ls_file.name.size }.max` to determine column width according to the longest file name (in the image below, it would be 19 because "credentials.yml.enc" is the longest, and see also [this](https://github.com/JunichiIto/ruby-practices/pull/2/files#diff-50ea26…) ![sample](https://user-images.githubusercontent.com/1148320/209256935-e849003a-1ac1-4244-a4c8-d21cb53aa5c5.png) I'd be pretty if I could write `column_width = @ls_files.max_of { |ls_file| ls_file.name.size }` . ---------------------------------------- Feature #17097: `map_min`, `map_max` https://bugs.ruby-lang.org/issues/17097#change-100762 * Author: sawa (Tsuyoshi Sawada) * Status: Open * Priority: Normal ---------------------------------------- `min`, `min_by`, `max`, `max_by` return the element that leads to the minimum or the maximum value, but I think it is as, or even more, frequent that we are interested in the minimum or the maximum value itself rather than the element. For example, to get the length of the longest string in an array, we do: ```ruby %w[aa b cccc dd].max_by(&:length).length # => 4 %w[aa b cccc dd].map(&:length).max # => 4 ``` I propose to have methods that return the minimum or the maximum value. Temporarily calling them `map_min`, `map_max`, they should work like this: ```ruby %w[aa b cccc dd].map_max(&:length) # => 4 ``` `map_min`, `map_max` are implementation-centered names, so perhaps better names should replace them, just like `yield_self` was replaced by `then`. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111220] [Ruby master Bug#19187] Ruby 3.1.3 testsuite fails after timezone 2022g update is applied
by coolo (Stephan Kulow) 22 Dec '22

22 Dec '22

Issue #19187 has been reported by coolo (Stephan Kulow). ---------------------------------------- Bug #19187: Ruby 3.1.3 testsuite fails after timezone 2022g update is applied https://bugs.ruby-lang.org/issues/19187 * Author: coolo (Stephan Kulow) * Status: Open * Priority: Normal * ruby -v: ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux-gnu] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- The timezone database changed incompatible to what ruby's testsuite expects. See the announcement here: http://mm.icann.org/pipermail/tz-announce/2022-November/000076.html and note the little detail Singapore's 1981-12-31 change was at 16:00 UTC (23:30 local time), not 24:00 local time. (Thanks to Geoff Clare via Robert Elz.) Problem is that test/ruby/test_time_tz.rb tests this very detail in 3 places - and breaks. 1) Failure: TestTimeTZ#test_asia_singapore [/home/abuild/rpmbuild/BUILD/ruby-3.1.3/test/ruby/test_time_tz.rb:143]: TZ=Asia/Singapore Time.local(1981, 12, 31, 23, 59, 59). <"1981-12-31 23:59:59 +0730"> expected but was <"1982-01-01 00:29:59 +0800">. 2) Failure: TestTimeTZ#test_gen_Asia_Singapore_22 [/home/abuild/rpmbuild/BUILD/ruby-3.1.3/test/ruby/test_time_tz.rb:382]: TZ=Asia/Singapore Time.utc(1981, 12, 31, 16, 29, 59).localtime. <"1981-12-31 23:59:59 +0730"> expected but was <"1982-01-01 00:29:59 +0800">. 3) Failure: TestTimeTZ#test_gen_Asia_Singapore_45 [/home/abuild/rpmbuild/BUILD/ruby-3.1.3/test/ruby/test_time_tz.rb:400]: TZ=Asia/Singapore Time.local(1981, 12, 31, 23, 59, 59). <"1981-12-31 23:59:59 +0730"> expected but was <"1982-01-01 00:29:59 +0800">. I can see no other option than not to test this detail - because relying on correct timezone data (either way) is barely possible. -- https://bugs.ruby-lang.org/

7 10

[ruby-core:111381] [Ruby master Bug#19251] Limit amount of test failures due to updates of tzdata
by vo.x (Vit Ondruch) 22 Dec '22

22 Dec '22

Issue #19251 has been reported by vo.x (Vit Ondruch). ---------------------------------------- Bug #19251: Limit amount of test failures due to updates of tzdata https://bugs.ruby-lang.org/issues/19251 * Author: vo.x (Vit Ondruch) * Status: Open * Priority: Normal * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- It seems that recently, Ruby test suite is broken ~ twice a year due to changes in tzdata. I am not sure how detailed the test suite needs to be to have the right amount of test coverage, but it would be nice if Ruby developers had more control above this changes then this changes being forced upon us via OS update. This is followup to #19187. BTW with my Fedora / RHEL maintainer hat on, this is a bit annoying, because: 1) It tends to hide other issues 2) In Fedora, it might block other development 3) Especially in RHEL, where there is not so big churn, it is unpleasant to start work on fixing CVE just to discover one needs to fix the tzdata test failures first -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111364] [Ruby master Bug#19249] Error running '__rvm_make -j8'
by hanumap (Hanuma Prasad) 22 Dec '22

22 Dec '22

Issue #19249 has been reported by hanumap (Hanuma Prasad). ---------------------------------------- Bug #19249: Error running '__rvm_make -j8' https://bugs.ruby-lang.org/issues/19249 * Author: hanumap (Hanuma Prasad) * Status: Open * Priority: Normal * ruby -v: 2.6. * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- Hi When I am trying to install rvm install 2.6 which is trying to install 2.6.6. Error: ruby-2.6.6 - #post-configuration - please wait ruby-2.6.6 - #compiling - please wait Error running '__rvm_make -j8', please read /Users/softint/.rvm/log/1671577997_ruby-2.6.6/make.log **** log file output: **** making srcs under enc make[1]: Nothing to be done for `srcs'. generating transdb.h linking static-library libruby.2.6-static.a linking shared-library libruby.2.6.dylib transdb.h updated Undefined symbols for architecture x86_64: "__mh_execute_header", referenced from: _rb_dump_backtrace_with_lines in addr2line.o ld: symbol(s) not found for architecture x86_64 clang: error: linker command failed with exit code 1 (use -v to see invocation) make: *** [libruby.2.6.dylib] Error 1 make: *** Waiting for unfinished jobs.... -- https://bugs.ruby-lang.org/

3 3

[ruby-core:111374] [Ruby master Feature#19000] Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object]
by ufuk (Ufuk Kayserilioglu) 22 Dec '22

22 Dec '22

Issue #19000 has been updated by ufuk (Ufuk Kayserilioglu). Thank you @matz and @naruse. I hate that this ended up being a last-minute change, but it seemed to be little risk adding a method to a new interface and the benefit seemed to greatly outweigh the risk. Otherwise, I would not have asked for consideration. Thanks again for your understanding. 🙇‍♂️ ---------------------------------------- Feature #19000: Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object] https://bugs.ruby-lang.org/issues/19000#change-100749 * Author: RubyBugs (A Nonymous) * Status: Closed * Priority: Normal ---------------------------------------- *As requested: extracted a follow-up to #16122 Data: simple immutable value object from [this comment](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/109815)* # Proposal: Add a "Copy with changes" method to Data Assume the proposed `Data.define` exists. Seeing examples from the [[Values gem]](https://github.com/ms-ati/Values): ```ruby require "values" # A new class Point = Value.new(:x, :y) # An immutable instance Origin = Point.with(x: 0, y: 0) # Q: How do we make copies that change 1 or more values? right = Origin.with(x: 1.0) up = Origin.with(y: 1.0) up_and_right = right.with(y: up.y) # In loops movements = [ [ :x, +0.5 ], [ :x, +0.5 ], [ :y, -1.0 ], [ :x, +0.5 ], ] # position = Point(x: 1.5, y: -1.0) position = movements.inject(Origin) do |p, (field, delta)| p.with(field => p.send(field) + delta) end ``` ## Proposed detail: Call this method: `#with` ```ruby Money = Data.define(:amount, :currency) account = Money.new(amount: 100, currency: 'USD') transactions = [+10, -5, +15] account = transactions.inject(account) { |a, t| a.with(amount: a.amount + t) } #=> Money(amount: 120, currency: "USD") ``` ## Why add this "Copy with changes" method to the Data simple immutable value class? Called on an instance, it returns a new instance with only the provided parameters changed. This API affordance is now **widely adopted across many languages** for its usefulness. Why is it so useful? Because copying immutable value object instances, with 1 or more discrete changes to specific fields, is the proper and ubiquitous pattern that takes the place of mutation when working with immutable value objects. **Other languages** C# Records: “immutable record structs — Non-destructive mutation” — is called `with { ... }` https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-t… Scala Case Classes — is called `#copy` https://docs.scala-lang.org/tour/case-classes.html Java 14+ Records — Brian Goetz at Oracle is working on adding a with copy constructor inspired by C# above as we speak, likely to be called `#with` https://mail.openjdk.org/pipermail/amber-spec-experts/2022-June/003461.html Rust “Struct Update Syntax” via `..` syntax in constructor https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-insta… ## Alternatives Without a copy-with-changes method, one must construct entirely new instances using the constructor. This can either be (a) fully spelled out as boilerplate code, or (b) use a symmetrical `#to_h` to feed the keyword-args constructor. **(a) Boilerplate using constructor** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(x: Origin.x, y: Origin.y, **change) ``` **(b) Using a separately proposed `#to_h` method and constructor symmetry** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(**(Origin.to_h.merge(change))) ``` Notice that the above are not ergonomic -- leading so many of our peer language communities to adopt the `#with` method to copy an instance with discrete changes. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111373] [Ruby master Feature#19000] Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object]
by naruse (Yui NARUSE) 22 Dec '22

22 Dec '22

Issue #19000 has been updated by naruse (Yui NARUSE). I'm also ok to merge! This will ship as a part of Ruby 3.2! ---------------------------------------- Feature #19000: Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object] https://bugs.ruby-lang.org/issues/19000#change-100747 * Author: RubyBugs (A Nonymous) * Status: Open * Priority: Normal ---------------------------------------- *As requested: extracted a follow-up to #16122 Data: simple immutable value object from [this comment](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/109815)* # Proposal: Add a "Copy with changes" method to Data Assume the proposed `Data.define` exists. Seeing examples from the [[Values gem]](https://github.com/ms-ati/Values): ```ruby require "values" # A new class Point = Value.new(:x, :y) # An immutable instance Origin = Point.with(x: 0, y: 0) # Q: How do we make copies that change 1 or more values? right = Origin.with(x: 1.0) up = Origin.with(y: 1.0) up_and_right = right.with(y: up.y) # In loops movements = [ [ :x, +0.5 ], [ :x, +0.5 ], [ :y, -1.0 ], [ :x, +0.5 ], ] # position = Point(x: 1.5, y: -1.0) position = movements.inject(Origin) do |p, (field, delta)| p.with(field => p.send(field) + delta) end ``` ## Proposed detail: Call this method: `#with` ```ruby Money = Data.define(:amount, :currency) account = Money.new(amount: 100, currency: 'USD') transactions = [+10, -5, +15] account = transactions.inject(account) { |a, t| a.with(amount: a.amount + t) } #=> Money(amount: 120, currency: "USD") ``` ## Why add this "Copy with changes" method to the Data simple immutable value class? Called on an instance, it returns a new instance with only the provided parameters changed. This API affordance is now **widely adopted across many languages** for its usefulness. Why is it so useful? Because copying immutable value object instances, with 1 or more discrete changes to specific fields, is the proper and ubiquitous pattern that takes the place of mutation when working with immutable value objects. **Other languages** C# Records: “immutable record structs — Non-destructive mutation” — is called `with { ... }` https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-t… Scala Case Classes — is called `#copy` https://docs.scala-lang.org/tour/case-classes.html Java 14+ Records — Brian Goetz at Oracle is working on adding a with copy constructor inspired by C# above as we speak, likely to be called `#with` https://mail.openjdk.org/pipermail/amber-spec-experts/2022-June/003461.html Rust “Struct Update Syntax” via `..` syntax in constructor https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-insta… ## Alternatives Without a copy-with-changes method, one must construct entirely new instances using the constructor. This can either be (a) fully spelled out as boilerplate code, or (b) use a symmetrical `#to_h` to feed the keyword-args constructor. **(a) Boilerplate using constructor** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(x: Origin.x, y: Origin.y, **change) ``` **(b) Using a separately proposed `#to_h` method and constructor symmetry** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(**(Origin.to_h.merge(change))) ``` Notice that the above are not ergonomic -- leading so many of our peer language communities to adopt the `#with` method to copy an instance with discrete changes. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111369] [Ruby master Misc#19250] The require path of MJIT
by k0kubun (Takashi Kokubun) 21 Dec '22

21 Dec '22

Issue #19250 has been reported by k0kubun (Takashi Kokubun). ---------------------------------------- Misc #19250: The require path of MJIT https://bugs.ruby-lang.org/issues/19250 * Author: k0kubun (Takashi Kokubun) * Status: Open * Priority: Normal ---------------------------------------- ## Background Since Ruby 3.2, MJIT is written in Ruby [Misc #18968]. We made it a `require`-able library instead of a builtin/prebuilt ISeq so that it will never be an extra overhead when MJIT is disabled. It's loaded with `require "mjit/compiler"` on prelude when --mjit is given. However, while it's technically a "standard library", we don't mean to maintain its backward compatibility. To make it clear, it's implemented as `RubyVM::MJIT::Compiler`, implying that it's CRuby-specific by prefixing `RubyVM::`, and make every constant under `RubyVM::MJIT` a private constant. Even if users manually require it, the interface is private. ## Discussion For consistency with the constant name `RubyVM::MJIT::Compiler` and to make it even clearer that we don't guarantee backward compatibility, @ko1 suggested to change `require "mjit/compiler"` to `require "ruby_vm/mjit/compiler"`. I'm fine with both ways, so I'll do so after confirming that with @matz. -- https://bugs.ruby-lang.org/

2 1