September 2025 - ruby-core - ml.ruby-lang.org

[ruby-core:122773] [Ruby Feature#21513] Raise on converting endless range to set
by viralpraxis (Iaroslav Kurbatov) 13 Nov '25

13 Nov '25

Issue #21513 has been reported by viralpraxis (Iaroslav Kurbatov). ---------------------------------------- Feature #21513: Raise on converting endless range to set https://bugs.ruby-lang.org/issues/21513 * Author: viralpraxis (Iaroslav Kurbatov) * Status: Open ---------------------------------------- Converting endless range to array raises: ``` shell ruby -e '(1..).to_a' -e:1:in 'Range#to_a': cannot convert endless range to an array (RangeError) from -e:1:in '<main>' ``` but converting to set does not: ``` shell ruby -e '(1..).to_set # hangs' ``` I think it makes to raise in both cases for consistency. Something like this should do the trick: ``` diff diff --git i/prelude.rb w/prelude.rb index f49cada637..11bfa3fc95 100644 --- i/prelude.rb +++ w/prelude.rb @@ -30,6 +30,10 @@ module Enumerable # Makes a set from the enumerable object with given arguments. # Passing arguments to this method is deprecated. def to_set(*args, &block) + if self.class == Range && self.end.nil? + raise RangeError, "cannot convert endless range to a set" + end + klass = if args.empty? Set else diff --git i/test/ruby/test_range.rb w/test/ruby/test_range.rb index f875c0ab40..27b968641b 100644 --- i/test/ruby/test_range.rb +++ w/test/ruby/test_range.rb @@ -1541,4 +1541,11 @@ def test_overlap? assert_not_operator((1...3), :overlap?, (3..4)) assert_not_operator((...3), :overlap?, (3..)) end + + def test_to_set + assert_equal(Set[], (1..-1).to_set) + assert_equal(Set[1, 2, 3], (1..3).to_set) + + assert_raise(RangeError) { (239..).to_set } + end end ``` If this patch is accepted, I'll open a PR. ``` shell ./ruby -v ruby 3.5.0dev (2025-07-14T20:34:32Z master a6d483971a) +PRISM [x86_64-linux] ``` -- https://bugs.ruby-lang.org/

5 7

[ruby-core:122343] [Ruby Misc#21385] Namespace: Suggesting a rename
by fxn (Xavier Noria) 11 Nov '25

11 Nov '25

Issue #21385 has been reported by fxn (Xavier Noria). ---------------------------------------- Misc #21385: Namespace: Suggesting a rename https://bugs.ruby-lang.org/issues/21385 * Author: fxn (Xavier Noria) * Status: Open ---------------------------------------- I'd like to suggest a rename of namespaces. The word "namespace" is already taken in Ruby. We say that classes and modules act as or represent. Constant paths nest them in practice. We say that it is a best practice that gems create their own namespace, etc. If the feature goes ahead with this name, the above sentences, well-established in the Ruby community, will start to sound confusing, because that meaning of "namespace" stays. If you look at the index in Matz's book, "namespaces" is indexed in pages 248–250. Title of section 7.5.1 is "Modules as Namespaces". Besides, I have had a few experiences explaining the proposal to people, and quickly realizing they assume this is something like C++ namespaces or Java packages. Then, I have to undo that mental model and start all over saying "forget that mental model". Those are like our constant paths, only more simple and strict. I think it may also be confusing in this sense (though this could be OK if it wasn't for the previous point.) To be constructive: Some alternative names that I have thought about are "isolates", "shields", or "cells". ("sandboxes" is close, but may have security connotations you do not want to suggest.) -- https://bugs.ruby-lang.org/

18 32

[ruby-core:123146] [Ruby Bug#21559] Unicode normalization nfd -> nfc -> nfd is not reversible
by tompng (tomoya ishida) 03 Nov '25

03 Nov '25

Issue #21559 has been reported by tompng (tomoya ishida). ---------------------------------------- Bug #21559: Unicode normalization nfd -> nfc -> nfd is not reversible https://bugs.ruby-lang.org/issues/21559 * Author: tompng (tomoya ishida) * Status: Open * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- I expect `nfd(nfc(str)) == nfd(str)` but found a string that doesn't. ~~~ruby # Ruby 3.1 - 3.5 str = "s\u{11930}\u{323}\u{11930}\u{307}" p str.unicode_normalize(:nfd) == str.unicode_normalize(:nfc).unicode_normalize(:nfd) #=> false ~~~ ~~~ruby # ruby 3.5.0dev str = "s\u{1611e}\u{323}\u{1611e}\u{307}\u{1611f}" p str.unicode_normalize(:nfd) == str.unicode_normalize(:nfc).unicode_normalize(:nfd) #=> false ~~~ -- https://bugs.ruby-lang.org/

4 7

[ruby-core:123172] [Ruby Bug#21560] RUBY_MN_THREADS=1 causes large performance regression in Puma 7
by schneems (Richard Schneeman) 02 Nov '25

02 Nov '25

Issue #21560 has been reported by schneems (Richard Schneeman). ---------------------------------------- Bug #21560: RUBY_MN_THREADS=1 causes large performance regression in Puma 7 https://bugs.ruby-lang.org/issues/21560 * Author: schneems (Richard Schneeman) * Status: Open * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- ## Expected Running a webserver with `RUBY_MN_THREADS=1` will increase performance or keep it the same. ## Actual - Before: 22919.85 Requests/sec - After: 2287.13 Requests/sec ## Reproduction Tracking this at https://github.com/puma/puma/issues/3720. I would like to get a smaller reproduction, but until then here's how we're able to induce the failure: Prepare puma: ``` $ git clone https://github.com/puma/puma $ cd puma $ git checkout v7.0.0.pre1 $ rake compile ``` Boot the server to deliver a "hello world" response: ``` $ bundle exec ruby -Ilib bin/puma -w 1 -t1 --preload test/rackup/hello.ru ``` Exercise the server with `wrk` (brew install wrk): ``` $ wrk -H 'Host: tfb-server' -H 'Accept: text/plain,text/html;q=0.9,application/xhtml+xml;q=0.9,application/xml;q=0.8,*/*;q=0.7' -H 'Connection: keep-alive' --latency -d 15 -c 16 --timeout 8 -t 12 http://localhost:9292 ``` ### Results Before: ``` $ bundle exec ruby -Ilib bin/puma -w 1 -t1 --preload test/rackup/hello.ru ``` ``` $ wrk -H 'Host: tfb-server' -H 'Accept: text/plain,text/html;q=0.9,application/xhtml+xml;q=0.9,application/xml;q=0.8,*/*;q=0.7' -H 'Connection: keep-alive' --latency -d 15 -c 16 --timeout 8 -t 12 http://localhost:9292 Running 15s test @ http://localhost:9292 12 threads and 16 connections Thread Stats Avg Stdev Max +/- Stdev Latency 786.74us 1.45ms 45.57ms 90.62% Req/Sec 1.92k 188.55 4.20k 83.22% Latency Distribution 50% 386.00us 75% 523.00us 90% 2.11ms 99% 4.63ms 344638 requests in 15.04s, 25.23MB read Requests/sec: 22919.85 Transfer/sec: 1.68MB ``` After: ``` $ env RUBY_MN_THREADS=1 bundle exec ruby -Ilib bin/puma -w 1 -t1 --preload test/rackup/hello.ru ``` ``` $ wrk -H 'Host: tfb-server' -H 'Accept: text/plain,text/html;q=0.9,application/xhtml+xml;q=0.9,application/xml;q=0.8,*/*;q=0.7' -H 'Connection: keep-alive' --latency -d 15 -c 16 --timeout 8 -t 12 http://localhost:9292 Running 15s test @ http://localhost:9292 12 threads and 16 connections Thread Stats Avg Stdev Max +/- Stdev Latency 28.89ms 40.82ms 129.37ms 78.94% Req/Sec 207.34 64.09 252.00 70.70% Latency Distribution 50% 212.00us 75% 56.77ms 90% 99.48ms 99% 127.01ms 34365 requests in 15.03s, 2.52MB read Requests/sec: 2287.13 Transfer/sec: 171.45KB ``` (Notice the dramatic drop in requests per second). -- https://bugs.ruby-lang.org/

8 12

[ruby-core:123350] [Ruby Bug#21618] Allow to use the build-in prism version to parse code
by Earlopain (Earlopain _) 29 Oct '25

29 Oct '25

Issue #21618 has been reported by Earlopain (Earlopain _). ---------------------------------------- Bug #21618: Allow to use the build-in prism version to parse code https://bugs.ruby-lang.org/issues/21618 * Author: Earlopain (Earlopain _) * Status: Open * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Prism is a multi-version parser, which is a great feature. If one calls `Prism.parse("foo")`, it will always use the latest version prism knows about. This may or may not be the version that is currently executing. This is problematic when one wants to introspect code the same way that the currently running ruby version would. Consider that some syntax will be disallowed in the next ruby version. I would have to specify the ruby version I want to parse as in order to not run into syntax errors: `Prism.parse("foo", version: RUBY_VERSION)`. But doing so is not feasable because `prism` is distributed out of sync with ruby itself. If the user already has prism in their lockfile, the user may run a prism version that doesn't yet know about lets say ruby 4.0 and thus raise. Similarly, it may parse as an older patch version that has subtle behaviour differences. `ripper` does not have this issue because it is always tied to the ruby version and it is not distributed as a gem, so what the user has will always be exactly what ruby shipped with. I wish for a similar API that utilizes the prism version bundled with ruby itself. Libraries like `rails` have moved from ripper to prism because of its superior developer experience but it risks breaking in unexpected ways with new `prism` versions that know about more recent syntax. `error_highlight` for example also suffers from the same defect. It seems like prism currently has 34 methods that optionally take a version (per the rbi file). Many of these are trivial helper methods like `Prism.parse_success?` (does the parse result have any errors?). I would be happy with supporting only the minimal functions like `Prism.parse` and `Prism.parse_file`. Currently I don't have a use-case for any of the other methods. Pretty much just functions to mirror `RubyVM::InstructionSequence.compile_file` and `RubyVM::InstructionSequence.compile`. It would be optimal if I would be able to transparently call `Prism.parse("foo", version: "current")` (or maybe even have an unspecified version mean the build-in prism version) but I am not sure how feasable that is since I'm pretty sure logic for this would have to live in ruby itself. @kddnewton does this feature request make sense? Do you have any other ideas/inputs? -- https://bugs.ruby-lang.org/

4 14

[ruby-core:123279] [Ruby Misc#21609] Propose Stan Lo (@st0012) as a core committer
by tekknolagi (Maxwell Bernstein) 28 Oct '25

28 Oct '25

Issue #21609 has been reported by tekknolagi (Maxwell Bernstein). ---------------------------------------- Misc #21609: Propose Stan Lo (@st0012) as a core committer https://bugs.ruby-lang.org/issues/21609 * Author: tekknolagi (Maxwell Bernstein) * Status: Open ---------------------------------------- ## Proposal I'd like to propose Stan Lo (@st0012) as a committer. He's been doing excellent work on ZJIT for the past couple of months, making sure we're compatible with the test suite, analyzing benchmark data, and optimizing the generated code. Especially since he has been contributing to Ruby for years now and knows the community, I think he should be able to merge his own changes. Here is Stan's message: ## Stan Lo's message I have been contributing to Ruby and core Ruby tools since 2021\. My main contributions have been: ### ZJIT Contributions ([60+ PRs](https://github.com/ruby/ruby/pulls?q=is%3Apr+author%3Ast0012+ZJIT+is%3…) - Made ZJIT work with TracePoint ([\#14407](https://github.com/ruby/ruby/pull/14407), [\#14420](https://github.com/ruby/ruby/pull/14420)) - Built infrastructure for annotating builtin functions ([\#14078](https://github.com/ruby/ruby/pull/14078)) - Implemented invalidation for method redefinition ([\#13875](https://github.com/ruby/ruby/pull/13875)), stable constants ([\#13998](https://github.com/ruby/ruby/pull/13998)), single Ractor mode ([\#14121](https://github.com/ruby/ruby/pull/14121)) - Supported compiling instructions: `concatstrings` ([\#14154](https://github.com/ruby/ruby/pull/14154)), `opt_and`/`opt_or` ([\#13830](https://github.com/ruby/ruby/pull/13830)), `invokeblock` ([\#14496](https://github.com/ruby/ruby/pull/14496)), `opt_case_dispatch` ([\#14433](https://github.com/ruby/ruby/pull/14433)) - Expanded test infrastructure to run against all Ruby tests ([\#13950](https://github.com/ruby/ruby/pull/13950)) ### Core Ruby Tools - **IRB** \- [All-time \#1 contributor](https://github.com/ruby/irb/graphs/contributors) and maintainer since 2022 - Implemented major features across Ruby 3.2-3.4: `cd` command, `edit` command, `show_cmds`, pager support, integration with `ruby/debug`…etc. - **RDoc** \- Maintainer since 2024 - Redesigned the default theme for Ruby 3.4+ ([\#1191](https://github.com/ruby/rdoc/pull/1191), [\#1157](https://github.com/ruby/rdoc/pull/1157)) - Created docs.ruby-lang.org with new homepage ([\#12227](https://github.com/ruby/ruby/pull/12227)) and greatly improved standard library page ([\#12404](https://github.com/ruby/ruby/pull/12404)) - **Debug** \- [\#2 contributor with 400+ commits](https://github.com/ruby/debug/graphs/contributors) - IRB integration ([\#1024](https://github.com/ruby/debug/pull/1024)) - `outline` command ([\#173](https://github.com/ruby/debug/pull/173)) - Backtrace filtering ([\#138](https://github.com/ruby/debug/pull/138)) I would like to continue contributing to ZJIT, IRB, RDoc, and other parts of Ruby. Being a committer would make it easier to maintain these critical tools and contribute to ZJIT's ongoing development. -- https://bugs.ruby-lang.org/

10 11

[ruby-core:122883] [Ruby Bug#21522] Accessing outer locals via eval in a Ractor returns false
by tenderlovemaking (Aaron Patterson) 24 Oct '25

24 Oct '25

Issue #21522 has been reported by tenderlovemaking (Aaron Patterson). ---------------------------------------- Bug #21522: Accessing outer locals via eval in a Ractor returns false https://bugs.ruby-lang.org/issues/21522 * Author: tenderlovemaking (Aaron Patterson) * Status: Open * Assignee: ractor * ruby -v: ruby 3.5.0dev (2025-07-28T22:17:45Z master f1acf47ca2) +PRISM [arm64-darwin24] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Normally, if you try to access a local that's been defined outside the scope of the Ractor block, it'll raise an ArgumentError. However, if you try to access the local via `eval` it will return the value `false`. ```ruby foo = Object.new begin Ractor.new { p foo }.value rescue ArgumentError end Ractor.new { p eval("foo") # => false }.value ``` I'm not sure how we fix this, since my guess is that we zero the environment when copying, but I wanted to file the issue so we can track it. -- https://bugs.ruby-lang.org/

2 1

[ruby-core:123241] [Ruby Feature#21572] Make illegal variable in alternation pattern a syntax error
by kddnewton (Kevin Newton) 23 Oct '25

23 Oct '25

Issue #21572 has been reported by kddnewton (Kevin Newton). ---------------------------------------- Feature #21572: Make illegal variable in alternation pattern a syntax error https://bugs.ruby-lang.org/issues/21572 * Author: kddnewton (Kevin Newton) * Status: Open ---------------------------------------- Currently when you have an illegal variable in an alternation pattern, you get a compile error, but no syntax error. ```ruby case foo in {a: } | Array "matched: #{a}" end ``` yields ``` $ ruby -cv test.rb ruby 3.5.0dev (2025-04-10T10:21:51Z master 756479324f) +PRISM [x86_64-linux] Syntax OK ``` but ``` $ ruby test.rb test.rb:2: illegal variable in alternative pattern (a) test.rb: compile error (SyntaxError) ``` Looking at the compiler, since illegal jumps (like break, next, etc.) are now syntax errors, the only other actual compiler errors are related to builtins. I think this should be a proper syntax error, so that editors and other tools can report on it and users can find it in development sooner. -- https://bugs.ruby-lang.org/

4 5

[ruby-core:123319] [Ruby Feature#21615] Introduce `Array#values`
by matheusrich (Matheus Richard) 23 Oct '25

23 Oct '25

Issue #21615 has been reported by matheusrich (Matheus Richard). ---------------------------------------- Feature #21615: Introduce `Array#values` https://bugs.ruby-lang.org/issues/21615 * Author: matheusrich (Matheus Richard) * Status: Open ---------------------------------------- ## Motivation In Ruby code, it's common to accept arrays and hashes and treat them uniformly as collections of values. `Hash` exposes `#values`, but `Array` does not, which pushes developers toward `is_a?`/`respond_to?` branching. Following the **Principle of Least Surprise**, users may reasonably expect `Array#values` to exist because: * Both `Array` **and** `Hash` already implement `#values_at`. * `Hash` implements `#values` but `Array` does not. ### Example Today: ```ruby def normalize_records(input) items = input.respond_to?(:values) ? input.values : input items.each do |item| do_stuff_with_item(item) end end ``` With `Array#values`: ```ruby def normalize_records(input) input.values.each do |item| do_stuff_with_item(item) end end ``` ## Proposal Add `Array#values`, returning `self`. Implementation could simply alias to `itself`: ```ruby class Array alias_method :values, :itself end ``` This yields a uniform interface for `Array` and `Hash` values without type checks. ### Alternatives considered * `Enumerable#values`: defaulting to `to_a`, but I found it too broad of a change. * `Array#each_value`: redundant as `Array#each` already covers iteration. Patch: https://github.com/ruby/ruby/pull/14641 -- https://bugs.ruby-lang.org/

6 8

[ruby-core:118243] [Ruby master Feature#20564] Switch default parser to Prism
by kddnewton (Kevin Newton) 22 Oct '25

22 Oct '25

Issue #20564 has been reported by kddnewton (Kevin Newton). ---------------------------------------- Feature #20564: Switch default parser to Prism https://bugs.ruby-lang.org/issues/20564 * Author: kddnewton (Kevin Newton) * Status: Open ---------------------------------------- This issue is to propose switching the default parser for Ruby to Prism on the master branch. The main goal is to get this default into both master and the next preview so that the community has plenty of time to test before the eventual 3.4 release. Matz has indicated that the final decision about the default parser for Ruby 3.4 will be made later in the year. Decisions about the default parser for Ruby 3.5+ and the relationship between Prism, lrama, parse.y, etc. will also be made at a later time. ## Background For some background on the Prism project itself, here are a couple of links in chronological order that you can read: * https://bugs.ruby-lang.org/issues/19741 * https://railsatscale.com/2023-06-12-rewriting-the-ruby-parser/ * https://kddnewton.com/2024/01/23/prism.html * https://railsatscale.com/2024-04-16-prism-in-2024/ ## Status Prism now passes all Ruby tests and specs. Internally at Shopify, it also passes our Core monolith's CI, which is a large and complex Rails application. We are confident that it is ready for production use. External to CRuby, Prism has already been adopted extensively around the ecosystem, including but not limited to: * [JRuby](https://github.com/jruby/jruby/pull/8103) (via Java) * [TruffleRuby](https://github.com/oracle/truffleruby/issues/3117) (via Java) * [Natalie](https://github.com/natalie-lang/natalie/pull/1213) (via C++ and Ruby) * [Opal](https://github.com/opal/opal/pull/2642) (via Ruby and WASM) * [repl_type_completor](https://github.com/ruby/repl_type_completor) * [rubocop](https://docs.rubocop.org/rubocop/configuration.html#setting-the-pa… (via parser translator) * [ruby-lsp](https://github.com/Shopify/ruby-lsp) * [packwerk](https://github.com/Shopify/packwerk/pull/388) (via parser translator) Fortunately with the community adoption, we have been able to find many edge cases and bugs that have been fixed. Thank you so much to everyone who has tried, used, reported problems with, and improved Prism in the last couple of years. We would not have hit this milestone without this community involvement. ## Caveats While Prism correctly accepts and parses all valid Ruby syntax, there are still a number of cases where it does not reject invalid syntax as it should. We are currently working on these cases, and we are confident that we can eliminate them before the next preview release. You can find them listed here: https://github.com/ruby/prism/issues?q=is%3Aopen+is%3Aissue+label%3Ainvalid…. This is our top priority right now, and I anticipate these being resolved quickly. The other caveat is unknown unknowns: bugs or syntax issues that we have yet to discover. At Shopify we are currently taking numerous steps to mitigate this risk, including: * Prism currently passes all Ruby tests and specs, and will continue to going forward. The tests and specs are extensive, and we are confident this gets us almost all of the way there. * Grammar-based fuzzing to ensure we handle all possible syntax variations (both valid and invalid). As an example, that recently led to the discovery that the current compiler was segfaulting on safe navigation in for loops (https://bugs.ruby-lang.org/issues/20468) It has also found several memory leaks that have been fixed. * Mutation testing of existing source files (by adding and deleting random bytes) to find additional edge cases. Our goal is 100% compatibility, and we believe this is achievable through the above techniques and others. The goal of this proposal is to allow more companies to test their codebase against Prism, and to make this easier. We believe that we can sort out the remaining problems much more quickly in that manner. ## Implementation The implementation will be relatively straightforward, as there is already the `--parser` flag that can be used to switch between the current parser and Prism. We will change the default to be `"prism"` instead of `"parse.y"`. There is no plan to remove or change any code related to `parse.y`, `lrama`, or `compile.c` at this time, as we want to create the minimal amount of change possible to ensure stability. -- https://bugs.ruby-lang.org/

4 10