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

[ruby-core:122958] [Ruby Feature#17316] On memoization
by Dan0042 (Daniel DeLorme) 12 Aug '25

12 Aug '25

Issue #17316 has been updated by Dan0042 (Daniel DeLorme). ixti (Alexey Zapparov) wrote in #note-14: > Firstly, rbocop is totally optional. Secondly, even rubocop is suggesting something more elegant than the above example: Ah yes you're right. I read "The new rule enforces this syntax" and took it at face value. But yeah the link has the much more common idiom `return @foo if defined?(@foo)` Also I got the impression this was an official style guide from the Rails team, but now I'm not so sure. Sorry for the overreaction. ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114263 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:122957] [Ruby Feature#17316] On memoization
by ixti (Alexey Zapparov) 12 Aug '25

12 Aug '25

Issue #17316 has been updated by ixti (Alexey Zapparov). > > ``` > > def foo > > if instance_variable_defined?(:@foo) > > @foo > > else > > @foo = Foo.find_by(id:) > > end > > end > > ``` > This is appalling. If "best practices" are going to encourage this kind of un-ruby-ish horror, this memoization issue is more urgent to solve than I had expected. Firstly, rbocop is totally optional. Secondly, even rubocop is suggesting something more elegant than the above example: ``` def current_user return @current_user if defined?(@current_user) @current_user = User.find_by(id: session[:user_id]) end ``` Which is, in my humble opinion, pretty common practice for memoizing falsey values in general. > Personally I prefer a DSL like `memo def foo` but this `@||=` idea is pretty interesting in how it communicates this is a syntax that applies to instance variables. Neither DSL nor proposed syntax are good IMO as they add a lot of cognitive burden. Although, I think DSL is still better if anything. ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114262 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:122943] [Ruby Bug#21537] rb_ractor_sched_barrier_start() hangs on Windows
by rhenium (Kazuki Yamaguchi) 12 Aug '25

12 Aug '25

Issue #21537 has been reported by rhenium (Kazuki Yamaguchi). ---------------------------------------- Bug #21537: rb_ractor_sched_barrier_start() hangs on Windows https://bugs.ruby-lang.org/issues/21537 * Author: rhenium (Kazuki Yamaguchi) * Status: Open * ruby -v: ruby 3.5.0dev (2025-08-09T11:32:53Z master 2a6345e957) +PRISM [x64-mswin64_140] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- The following script hangs at `GC.start` indefinitely. Pressing Ctrl+C on the terminal interrupts the `sleep` and it appears to resume and prints "in_ractor". ```ruby Ractor.new { sleep 1 GC.start puts "in_ractor" } sleep ``` I also reproduced this with Ruby 3.0.7 from RubyInstaller2. Here is the stack trace with master: ``` 0:006> ~*k 0 Id: 1e88.36c4 Suspend: 1 Teb: 000000c6`92478000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`929fef18 00007ffa`9e4edf43 ntdll!NtWaitForMultipleObjects+0x14 01 000000c6`929fef20 00007ffa`9e4ede11 KERNELBASE!WaitForMultipleObjectsEx+0x123 02 000000c6`929ff210 00007ff6`756b8164 KERNELBASE!WaitForMultipleObjects+0x11 03 000000c6`929ff250 00007ff6`756b13af miniruby!w32_wait_events+0x108 [C:\w\ruby\thread_win32.c @ 239] 04 000000c6`929ff2d0 00007ff6`756b62a2 miniruby!native_sleep+0xc3 [C:\w\ruby\thread_win32.c @ 360] 05 000000c6`929ff310 00007ff6`75646353 miniruby!sleep_forever+0x82 [C:\w\ruby\thread.c @ 1374] 06 000000c6`929ff350 00007ff6`756e5f4b miniruby!rb_f_sleep+0x53 [C:\w\ruby\process.c @ 4975] 07 000000c6`929ff380 00007ff6`756e5df9 miniruby!vm_call_cfunc_with_frame_+0x14b [C:\w\ruby\vm_insnhelper.c @ 3850] 08 000000c6`929ff460 00007ff6`756e5dbb miniruby!vm_call_cfunc_with_frame+0x29 [C:\w\ruby\vm_insnhelper.c @ 3895] 09 000000c6`929ff4a0 00007ff6`756e5ab7 miniruby!vm_call_cfunc_other+0xc7 [C:\w\ruby\vm_insnhelper.c @ 3922] 0a 000000c6`929ff4e0 00007ff6`756e8363 miniruby!vm_call_cfunc+0x10b [C:\w\ruby\vm_insnhelper.c @ 4003] 0b 000000c6`929ff510 00007ff6`756e7cfe miniruby!vm_call_method_each_type+0x637 [C:\w\ruby\vm_insnhelper.c @ 4827] 0c 000000c6`929ff610 00007ff6`756f39b4 miniruby!vm_call_method+0x152 [C:\w\ruby\vm_insnhelper.c @ 4991] 0d 000000c6`929ff680 00007ff6`756ee003 miniruby!vm_sendish+0x1f4 [C:\w\ruby\vm_insnhelper.c @ 6065] 0e 000000c6`929ff700 00007ff6`756e0f27 miniruby!vm_exec_core+0x25cb [C:\w\ruby\insns.def @ 900] 0f (Inline Function) --------`-------- miniruby!vm_exec_loop+0x8 [C:\w\ruby\vm.c @ 2653] 10 000000c6`929ff860 00007ff6`755b896f miniruby!rb_vm_exec+0x10b [C:\w\ruby\vm.c @ 2624] 11 000000c6`929ff9d0 00007ff6`755baf47 miniruby!rb_ec_exec_node+0x10f [C:\w\ruby\eval.c @ 284] 12 000000c6`929ffb50 00007ff6`75531069 miniruby!ruby_run_node+0x43 [C:\w\ruby\eval.c @ 320] 13 (Inline Function) --------`-------- miniruby!rb_main+0x25 [C:\w\ruby\main.c @ 42] 14 (Inline Function) --------`-------- miniruby!w32_main+0x5f [C:\w\ruby\main.c @ 62] 15 000000c6`929ffb80 00007ff6`7575e3ec miniruby!wmain+0x69 [C:\w\ruby\main.c @ 48] 16 (Inline Function) --------`-------- miniruby!invoke_main+0x22 [D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl @ 90] 17 000000c6`929ffbb0 00007ffa`a03de8d7 miniruby!__scrt_common_main_seh+0x10c [D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl @ 288] 18 000000c6`929ffbf0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 19 000000c6`929ffc20 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 1 Id: 1e88.1468 Suspend: 1 Teb: 000000c6`9247a000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`92dff618 00007ffa`a103259e ntdll!NtWaitForWorkViaWorkerFactory+0x14 01 000000c6`92dff620 00007ffa`a03de8d7 ntdll!TppWorkerThread+0x37e 02 000000c6`92dff980 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`92dff9b0 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 2 Id: 1e88.1058 Suspend: 1 Teb: 000000c6`9247c000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`931ff6a8 00007ffa`a103259e ntdll!NtWaitForWorkViaWorkerFactory+0x14 01 000000c6`931ff6b0 00007ffa`a03de8d7 ntdll!TppWorkerThread+0x37e 02 000000c6`931ffa10 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`931ffa40 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 3 Id: 1e88.158c Suspend: 1 Teb: 000000c6`9247e000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`935ff998 00007ffa`a103259e ntdll!NtWaitForWorkViaWorkerFactory+0x14 01 000000c6`935ff9a0 00007ffa`a03de8d7 ntdll!TppWorkerThread+0x37e 02 000000c6`935ffd00 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`935ffd30 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 4 Id: 1e88.3acc Suspend: 1 Teb: 000000c6`92480000 Unfrozen "ruby-timer-thread" # Child-SP RetAddr Call Site 00 000000c6`936ffbc8 00007ffa`9e4ecbbf ntdll!NtWaitForSingleObject+0x14 01 000000c6`936ffbd0 00007ff6`756b7e9d KERNELBASE!WaitForSingleObjectEx+0xaf 02 000000c6`936ffc70 00007ffa`9e0d37b0 miniruby!timer_thread_func+0x45 [C:\w\ruby\thread_win32.c @ 777] 03 000000c6`936ffca0 00007ffa`a03de8d7 ucrtbase!thread_start<unsigned int (__cdecl*)(void *),1>+0x30 04 000000c6`936ffcd0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 05 000000c6`936ffd00 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 5 Id: 1e88.2934 Suspend: 1 Teb: 000000c6`92482000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`937ff4f8 00007ffa`9e4ecbbf ntdll!NtWaitForSingleObject+0x14 01 000000c6`937ff500 00007ff6`756b1276 KERNELBASE!WaitForSingleObjectEx+0xaf 02 000000c6`937ff5a0 00007ff6`756f7f47 miniruby!native_cond_timedwait_ms+0x62 [C:\w\ruby\thread_win32.c @ 483] 03 (Inline Function) --------`-------- miniruby!vm_cond_wait+0x28 [C:\w\ruby\vm_sync.c @ 211] 04 000000c6`937ff5f0 00007ff6`756b2c83 miniruby!rb_vm_cond_wait+0x37 [C:\w\ruby\vm_sync.c @ 220] 05 000000c6`937ff620 00007ff6`756f7f02 miniruby!rb_ractor_sched_barrier_start+0x67 [C:\w\ruby\thread_win32.c @ 956] 06 000000c6`937ff650 00007ff6`755c7a78 miniruby!rb_vm_barrier+0x1e [C:\w\ruby\vm_sync.c @ 265] 07 (Inline Function) --------`-------- miniruby!rb_gc_vm_barrier+0x5 [C:\w\ruby\gc.c @ 179] 08 (Inline Function) --------`-------- miniruby!gc_enter+0x25 [C:\w\ruby\gc\default\default.c @ 6609] 09 000000c6`937ff680 00007ff6`755c442e miniruby!gc_start+0xc0 [C:\w\ruby\gc\default\default.c @ 6334] 0a 000000c6`937ff6e0 00007ff6`755cdd0f miniruby!garbage_collect+0x42 [C:\w\ruby\gc\default\default.c @ 6316] 0b 000000c6`937ff710 00007ff6`755c2cc3 miniruby!rb_gc_impl_start+0x4b [C:\w\ruby\gc\default\default.c @ 6767] 0c 000000c6`937ff740 00007ff6`756d5c7b miniruby!gc_start_internal+0x4f [C:\w\ruby\gc.c @ 3447] 0d 000000c6`937ff780 00007ff6`756ee237 miniruby!builtin_invoker4+0x23 [C:\w\ruby\vm_insnhelper.c @ 7373] 0e (Inline Function) --------`-------- miniruby!invoke_bf+0x32 [C:\w\ruby\vm_insnhelper.c @ 7485] 0f (Inline Function) --------`-------- miniruby!vm_invoke_builtin+0x32 [C:\w\ruby\vm_insnhelper.c @ 7493] 10 000000c6`937ff7c0 00007ff6`756e0f27 miniruby!vm_exec_core+0x27ff [C:\w\ruby\build-debug\vm.inc @ 4621] 11 (Inline Function) --------`-------- miniruby!vm_exec_loop+0x8 [C:\w\ruby\vm.c @ 2653] 12 000000c6`937ff920 00007ff6`756f08b0 miniruby!rb_vm_exec+0x10b [C:\w\ruby\vm.c @ 2624] 13 (Inline Function) --------`-------- miniruby!invoke_iseq_block_from_c+0x1e3 [C:\w\ruby\vm.c @ 1651] 14 (Inline Function) --------`-------- miniruby!invoke_block_from_c_proc+0x2f2 [C:\w\ruby\vm.c @ 1745] 15 000000c6`937ffa90 00007ff6`756b6bf9 miniruby!vm_invoke_proc+0x324 [C:\w\ruby\vm.c @ 1775] 16 000000c6`937ffbd0 00007ff6`756b7987 miniruby!thread_do_start_proc+0x131 [C:\w\ruby\thread.c @ 584] 17 (Inline Function) --------`-------- miniruby!thread_do_start+0x37 [C:\w\ruby\thread.c @ 626] 18 000000c6`937ffc40 00007ff6`756b7720 miniruby!thread_start_func_2+0x243 [C:\w\ruby\thread.c @ 677] 19 000000c6`937ffe90 00007ffa`9e0d37b0 miniruby!thread_start_func_1+0x74 [C:\w\ruby\thread_win32.c @ 659] 1a 000000c6`937ffec0 00007ffa`a03de8d7 ucrtbase!thread_start<unsigned int (__cdecl*)(void *),1>+0x30 1b 000000c6`937ffef0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 1c 000000c6`937fff20 00000000`00000000 ntdll!RtlUserThreadStart+0x2c # 6 Id: 1e88.4f4 Suspend: 1 Teb: 000000c6`92486000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`93bff768 00007ffa`a10d793e ntdll!DbgBreakPoint 01 000000c6`93bff770 00007ffa`a03de8d7 ntdll!DbgUiRemoteBreakin+0x4e 02 000000c6`93bff7a0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`93bff7d0 00000000`00000000 ntdll!RtlUserThreadStart+0x2c ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:122951] [Ruby Feature#17316] On memoization
by Dan0042 (Daniel DeLorme) 11 Aug '25

11 Aug '25

Issue #17316 has been updated by Dan0042 (Daniel DeLorme). marksiemers (Mark Siemers) wrote in #note-12: > A big motivation for this comes from a recent change to rubocop-rails, which is now enforcing "Rails/FindByOrAssignmentMemoization" (see: https://rails.rubystyle.guide/\#find-by-memoization) > > A more rails-specific example below of this proposal: > ```ruby > # Previously allowed (though not performant in the case of nil returned by find_by) > def foo > @foo ||= Foo.find_by(id:) > end > > # The new rule enforces this syntax > def foo > if instance_variable_defined?(:@foo) > @foo > else > @foo = Foo.find_by(id:) > end > end > ``` This is appalling. If "best practices" are going to encourage this kind of un-ruby-ish horror, this memoization issue is more urgent to solve than I had expected. Personally I prefer a DSL like `memo def foo` but this `@||=` idea is pretty interesting in how it communicates this is a syntax that applies to instance variables. ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114255 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:121136] [Ruby master Bug#21151] IO and StringIO raise FrozenError even for read-only methods
by headius (Charles Nutter) 11 Aug '25

11 Aug '25

Issue #21151 has been reported by headius (Charles Nutter). ---------------------------------------- Bug #21151: IO and StringIO raise FrozenError even for read-only methods https://bugs.ruby-lang.org/issues/21151 * Author: headius (Charles Nutter) * Status: Open * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Problem -------- While fixing a small [regression](https://github.com/ruby/stringio/issues/119) from my recent StringIO [fixes](https://github.com/ruby/stringio/issues/116) I discovered that a large number of read-only methods will fail if the StringIO is frozen. A few examples: ``` $ ruby -rstringio -e 's = StringIO.new; p s.lineno; s.freeze; p s.lineno' 0 -e:1:in 'StringIO#lineno': can't modify frozen StringIO: #<StringIO:0x0000000103711ea8> (FrozenError) from -e:1:in '<main>' $ ruby -rstringio -e 's = StringIO.new; p s.closed?; s.freeze; p s.closed?' false -e:1:in 'StringIO#closed?': can't modify frozen StringIO: #<StringIO:0x00000001008c1e68> (FrozenError) from -e:1:in '<main>' $ ruby -rstringio -e 's = StringIO.new; p s.eof?; s.freeze; p s.eof?' true -e:1:in 'StringIO#eof?': can't modify frozen StringIO: #<StringIO:0x000000011c171e80> (FrozenError) from -e:1:in '<main>' $ ruby -rstringio -e 's = StringIO.new; p s.pos; s.freeze; p s.pos' 0 -e:1:in 'StringIO#pos': can't modify frozen StringIO: #<StringIO:0x0000000105551df0> (FrozenError) from -e:1:in '<main>' ``` @kou pointed out that IO also raises for at least `lineno` and suggested I re-open the issue here. I still believe these read-only operations should be allowed on frozen IO or StringIO. Cause in StringIO ----------------- This is because the `StringIO` macro calls `get_strio` which calls `rb_io_taint_check` which calls `rb_check_frozen`. The `StringIO` macro is used in almost every method to access the rb_stringio_t data structure. A list of methods I believe should be operable when the StringIO is frozen (in stringio.c definition order): * string (returns underlying String but does not mutate anything) * lineno * pos * closed?/closed_read?/closed_write? * eof/eof? * sync * pid (a dummy method but it writes nothing) * fileno (dummy) * pread (by definition does not modify state) * isatty/tty? * size/length * external_encoding * internal_encoding In addition, `initialize_copy` probably should not require the original StringIO to be writable: ``` $ ruby -rstringio -e 's = StringIO.new("foo"); s.freeze; p s.dup' -e:1:in 'StringIO#initialize_copy': can't modify frozen StringIO: #<StringIO:0x0000000102eb1df8> (FrozenError) from -e:1:in 'Kernel#initialize_dup' from -e:1:in 'Kernel#dup' from -e:1:in '<main>' ``` The data from the original StringIO is unmodified by `initialize_copy`, other than the reference-counting `ptr->count` (which should not be subject to frozen checks). Cause in IO ----------- The `GetOpenFile` macro calls `RB_IO_POINTER` macro which calls `rb_io_taint_check` which calls `rb_check_frozen`. Methods in IO that should work on a frozen IO include any of the above StringIO that currently raise. For example `lineno` uses `GetOpenFile`, but `fileno` does not and does not raise. There's clearly some inconsistency here we can clean up. Origin ------ I believe most of the StringIO cases are caused by this change from 2011 that added frozen checks to StringIO (the class and the macro): https://github.com/ruby/ruby/commit/d8d9bac5c8b071135e50ad3f21c8a9b6a9c06e54 In IO, this behavior dates way back to 2000 by @matz himself: https://github.com/ruby/ruby/commit/087c83d7ceed6893afff93066937fb570ae4a115 Notes ----- I have started to fix the StringIO cases for JRuby in https://github.com/ruby/stringio/pull/122. I could probably fix the C version of StringIO as well, but I'm a little more unsure about how to fix IO. -- https://bugs.ruby-lang.org/

3 4

[ruby-core:122948] [Ruby Feature#17316] On memoization
by marksiemers (Mark Siemers) 11 Aug '25

11 Aug '25

Issue #17316 has been updated by marksiemers (Mark Siemers). I agree with Sebastian that an operator is the best way to keep this code elegant. My proposal is to: **Introduce a new operator `@||` that does instance variable aware memoization succinctly** ```ruby # Allow this syntax def result @result @||= expensive_calculation end # As functionally equivalent to this def result if instance_variable_defined?(:@result) @result else @result = expensive_calculation end end ``` Reasons for this suggestion: 1. `@|` is already not valid syntax, so there should not be any issue with breaking legacy code 2. Use of the `@` symbol is a strong indicator that this impacts and is useful for instance variables 3. Keeping the `||` as part of the operator is familiar syntax for memoization 4. It is succinct, keeps things on one line, adds only one character, does not require blocks or method calls on separate lines (e.g. `memoize(:result)`) 5. If searching for memoization in the codebase - searching for `||=` will still work --- A big motivation for this comes from a recent change to rubocop-rails, which is now enforcing "Rails/FindByOrAssignmentMemoization" (see: https://rails.rubystyle.guide/\#find-by-memoization) A more rails-specific example below of this proposal: ```ruby # Previously allowed (though not performant in the case of nil returned by find_by def foo @foo ||= Foo.find_by(id:) end # The new rule enforces this syntax def foo if instance_variable_defined?(:@foo) @foo else @foo = Foo.find_by(id:) end end ``` Here's my main proposal with some reasons behind it: ```ruby def foo @foo @||= Foo.find_by(id:) end ``` --- Here are some other ideas, but I don't think any of them are as good as `@||`: ```ruby @result |||= expensive_calculation @result -||= expensive_calculation @result +||= expensive_calculation @result _||= expensive_calculation @result &||= expensive_calculation @result %||= expensive_calculation ``` ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114252 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:122939] [Ruby Bug#21536] ERROR: Error installing tk:
by sevkme (sevk kk) 09 Aug '25

09 Aug '25

Issue #21536 has been reported by sevkme (sevk kk). ---------------------------------------- Bug #21536: ERROR: Error installing tk: https://bugs.ruby-lang.org/issues/21536 * Author: sevkme (sevk kk) * Status: Open * ruby -v: ruby 3.4.4 (2025-05-14 revision a38531fd3f) +YJIT +PRISM [x86_64-linux] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- ``` shell kkar4 :: ~ » pacman -Ss tcl | grep install extra/tcl 8.6.16-1 [installed] extra/tk 8.6.16-1 [installed] ``` ``` shell kkar4 :: ~ » CFLAGS="-Wold-style-definition" gem install tk Building native extensions. This could take a while... ERROR: Error installing tk: ERROR: Failed to build gem native extension. current directory: /usr/lib/ruby/gems/3.4.0/gems/tk-0.5.1/ext/tk /usr/bin/ruby extconf.rb check functions.checking for ruby_native_thread_p() in ruby.h... yes checking for rb_errinfo() in ruby.h... yes checking for rb_hash_lookup() in ruby.h... yes checking for rb_proc_new() in ruby.h... yes checking for rb_sourcefile() in ruby.h... yes checking for rb_thread_alive_p() in ruby.h... no checking for rb_thread_check_trap_pending() in ruby.h... yes checking for ruby_enc_find_basename() in ruby.h... yes check libraries.checking for t_open() in -lnsl... no checking for socket() in -lsocket... no checking for dlopen() in -ldl... yes checking for log() in -lm... yes Use ActiveTcl libraries (if available). Search tclConfig.sh and tkConfig.sh. Valid [tclConfig.sh, tkConfig.sh] are found in [["/usr/lib", "/usr/lib"], ["/usr/lib64", "/usr/lib64"]] Use [tclConfig.sh, tkConfig.sh] == ["/usr/lib/tclConfig.sh", "/usr/lib/tkConfig.sh"] Use X11 libraries (or use TK_XINCLUDES/TK_XLIBSW information on tkConfig.sh). checking for XOpenDisplay() in -lX11... yes creating Makefile Find Tcl/Tk libraries. Make tcltklib.so which is required by Ruby/Tk. current directory: /usr/lib/ruby/gems/3.4.0/gems/tk-0.5.1/ext/tk make DESTDIR\= sitearchdir\=./.gem.20250809-2512403-8d3buu sitelibdir\=./.gem.20250809-2512403-8d3buu clean current directory: /usr/lib/ruby/gems/3.4.0/gems/tk-0.5.1/ext/tk make DESTDIR\= sitearchdir\=./.gem.20250809-2512403-8d3buu sitelibdir\=./.gem.20250809-2512403-8d3buu compiling stubs.c stubs.c: In function '_nativethread_consistency_check': stubs.c:42:1: warning: old-style function definition [-Wold-style-definition] 42 | _nativethread_consistency_check(ip) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ compiling tcltklib.c tcltklib.c: In function 'get_ip': tcltklib.c:784:1: warning: old-style function definition [-Wold-style-definition] 784 | get_ip(self) | ^~~~~~ tcltklib.c: In function 'deleted_ip': tcltklib.c:802:1: warning: old-style function definition [-Wold-style-definition] 802 | deleted_ip(ptr) | ^~~~~~~~~~ tcltklib.c: In function 'rbtk_preserve_ip': tcltklib.c:818:1: warning: old-style function definition [-Wold-style-definition] 818 | rbtk_preserve_ip(ptr) | ^~~~~~~~~~~~~~~~ tcltklib.c: In function 'rbtk_release_ip': tcltklib.c:832:1: warning: old-style function definition [-Wold-style-definition] 832 | rbtk_release_ip(ptr) | ^~~~~~~~~~~~~~~ tcltklib.c: In function 'tcltkip_init_tk': tcltklib.c:1327:1: warning: old-style function definition [-Wold-style-definition] 1327 | tcltkip_init_tk(interp) | ^~~~~~~~~~~~~~~ tcltklib.c: In function 'pending_exception_check1': tcltklib.c:1435:1: warning: old-style function definition [-Wold-style-definition] 1435 | pending_exception_check1(thr_crit_bup, ptr) | ^~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'call_original_exit': tcltklib.c:1480:1: warning: old-style function definition [-Wold-style-definition] 1480 | call_original_exit(ptr, state) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function '_timer_for_tcl': tcltklib.c:1631:1: warning: old-style function definition [-Wold-style-definition] 1631 | _timer_for_tcl(clientData) | ^~~~~~~~~~~~~~ tcltklib.c: In function 'set_eventloop_window_mode': tcltklib.c:1682:1: warning: old-style function definition [-Wold-style-definition] 1682 | set_eventloop_window_mode(self, mode) | ^~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_eventloop_window_mode': tcltklib.c:1697:1: warning: old-style function definition [-Wold-style-definition] 1697 | get_eventloop_window_mode(self) | ^~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_eventloop_tick': tcltklib.c:1708:1: warning: old-style function definition [-Wold-style-definition] 1708 | set_eventloop_tick(self, tick) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_eventloop_tick': tcltklib.c:1742:1: warning: old-style function definition [-Wold-style-definition] 1742 | get_eventloop_tick(self) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_set_eventloop_tick': tcltklib.c:1749:1: warning: old-style function definition [-Wold-style-definition] 1749 | ip_set_eventloop_tick(self, tick) | ^~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_get_eventloop_tick': tcltklib.c:1768:1: warning: old-style function definition [-Wold-style-definition] 1768 | ip_get_eventloop_tick(self) | ^~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_no_event_wait': tcltklib.c:1775:1: warning: old-style function definition [-Wold-style-definition] 1775 | set_no_event_wait(self, wait) | ^~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_no_event_wait': tcltklib.c:1793:1: warning: old-style function definition [-Wold-style-definition] 1793 | get_no_event_wait(self) | ^~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_set_no_event_wait': tcltklib.c:1800:1: warning: old-style function definition [-Wold-style-definition] 1800 | ip_set_no_event_wait(self, wait) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_get_no_event_wait': tcltklib.c:1819:1: warning: old-style function definition [-Wold-style-definition] 1819 | ip_get_no_event_wait(self) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_eventloop_weight': tcltklib.c:1826:1: warning: old-style function definition [-Wold-style-definition] 1826 | set_eventloop_weight(self, loop_max, no_event) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_eventloop_weight': tcltklib.c:1846:1: warning: old-style function definition [-Wold-style-definition] 1846 | get_eventloop_weight(self) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_set_eventloop_weight': tcltklib.c:1853:1: warning: old-style function definition [-Wold-style-definition] 1853 | ip_set_eventloop_weight(self, loop_max, no_event) | ^~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_get_eventloop_weight': tcltklib.c:1873:1: warning: old-style function definition [-Wold-style-definition] 1873 | ip_get_eventloop_weight(self) | ^~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_max_block_time': tcltklib.c:1880:1: warning: old-style function definition [-Wold-style-definition] 1880 | set_max_block_time(self, time) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_evloop_thread_p': tcltklib.c:1913:1: warning: old-style function definition [-Wold-style-definition] 1913 | lib_evloop_thread_p(self) | ^~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_evloop_abort_on_exc': tcltklib.c:1926:1: warning: old-style function definition [-Wold-style-definition] 1926 | lib_evloop_abort_on_exc(self) | ^~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_evloop_abort_on_exc': tcltklib.c:1939:1: warning: old-style function definition [-Wold-style-definition] 1939 | ip_evloop_abort_on_exc(self) | ^~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_evloop_abort_on_exc_set': tcltklib.c:1946:1: warning: old-style function definition [-Wold-style-definition] 1946 | lib_evloop_abort_on_exc_set(self, val) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_evloop_abort_on_exc_set': tcltklib.c:1960:1: warning: old-style function definition [-Wold-style-definition] 1960 | ip_evloop_abort_on_exc_set(self, val) | ^~~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_num_of_mainwindows_core': tcltklib.c:1979:1: warning: old-style function definition [-Wold-style-definition] 1979 | lib_num_of_mainwindows_core(self, argc, argv) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_num_of_mainwindows': tcltklib.c:1992:1: warning: old-style function definition [-Wold-style-definition] 1992 | lib_num_of_mainwindows(self) | ^~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'call_DoOneEvent': tcltklib.c:2045:21: error: passing argument 1 of 'tk_funcall' from incompatible pointer type [-Wincompatible-pointer-types] 2045 | return tk_funcall(call_DoOneEvent_core, 0, (VALUE*)NULL, flag_val); | ^~~~~~~~~~~~~~~~~~~~ | | | VALUE (*)(VALUE) {aka long unsigned int (*)(long unsigned int)} In file included from /usr/include/ruby-3.4.0/ruby/defines.h:77, from /usr/include/ruby-3.4.0/ruby/ruby.h:25, from /usr/include/ruby-3.4.0/ruby.h:38, from tcltklib.c:10: tcltklib.c:258:28: note: expected 'VALUE (*)(void)' {aka 'long unsigned int (*)(void)'} but argument is of type 'VALUE (*)(VALUE)' {aka 'long unsigned int (*)(long unsigned int)'} 258 | static VALUE tk_funcall _((VALUE(), int, VALUE*, VALUE)); | ^~~~~~~ /usr/include/ruby-3.4.0/ruby/backward/2/stdarg.h:33:18: note: in definition of macro '_' 33 | # define _(args) args | ^~~~ tcltklib.c:2021:1: note: 'call_DoOneEvent_core' declared here 2021 | call_DoOneEvent_core(VALUE flag_val) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_eventloop_core': tcltklib.c:2197:1: warning: old-style function definition [-Wold-style-definition] 2197 | lib_eventloop_core(check_root, update_flag, check_var, interp) | ^~~~~~~~~~~~~~~~~~ ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:122915] [Ruby Bug#21531] /usr/src/ruby/vm_insnhelper.c:131: Assertion Failed: callable_method_entry_p:IMEMO_TYPE_P((VALUE)cme, imemo_ment): imemo_type:env
by yahonda (Yasuo Honda) 07 Aug '25

07 Aug '25

Issue #21531 has been reported by yahonda (Yasuo Honda). ---------------------------------------- Bug #21531: /usr/src/ruby/vm_insnhelper.c:131: Assertion Failed: callable_method_entry_p:IMEMO_TYPE_P((VALUE)cme, imemo_ment): imemo_type:env https://bugs.ruby-lang.org/issues/21531 * Author: yahonda (Yasuo Honda) * Status: Open * ruby -v: 3.5.0p-1 (2025-08-02 revision fca2e6f8f53920170654e696c2585fcd3f4ebe11) [x86_64-linux] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Rails CI is consistently throwing assertion failures, but I can't replicate this behavior locally yet. https://buildkite.com/rails/rails-nightly/builds/2619#0198676f-b98c-4c4e-a6… ``` /usr/local/bin/ruby -w -I"lib:test" /usr/local/lib/ruby/gems/3.5.0+2/gems/rake-13.3.0/lib/rake/rake_test_loader.rb "test/activejob/destroy_association_async_job_test.rb" "test/activejob/destroy_association_async_test.rb" "test/activejob/job_checkpoints_test.rb" "test/activejob/job_runtime_test.rb" --profile /usr/local/lib/ruby/gems/3.5.0+2/gems/i18n-1.14.7/lib/i18n/exceptions.rb:3: warning: CGI library is removed from Ruby 3.5. Please use cgi/escape instead for CGI.escape and CGI.unescape features. If you need to use the full features of CGI library, Please install cgi gem. /usr/src/ruby/vm_insnhelper.c:131: Assertion Failed: callable_method_entry_p:IMEMO_TYPE_P((VALUE)cme, imemo_ment): imemo_type:env ruby 3.5.0dev (2025-08-01T16:00:05Z master fca2e6f8f5) +PRISM [x86_64-linux] ``` ### Environment - Using rubylang/ruby:master-debug Docker image provided via https://hub.docker.com/r/rubylang/ruby/ - Last successful build with Ruby 3.5.0p-1 (2025-08-01 revision b3598cf2a355497693bb66097edc156af3152e9b) [x86_64-linux] https://buildkite.com/rails/rails-nightly/builds/2614#01986249-5d8f-4315-ba… - I suspect this problem was introduced by one of the commits in this range: https://github.com/ruby/ruby/compare/b3598cf2a355497693bb66097edc156af3152e… -- https://bugs.ruby-lang.org/

2 1

[ruby-core:111789] [Ruby master Feature#19333] Setting (Fiber Local|Thread Local|Fiber Storage) to nil should delete value in order to avoid memory leaks.
by ioquatix (Samuel Williams) 07 Aug '25

07 Aug '25

Issue #19333 has been reported by ioquatix (Samuel Williams). ---------------------------------------- Feature #19333: Setting (Fiber Local|Thread Local|Fiber Storage) to nil should delete value in order to avoid memory leaks. https://bugs.ruby-lang.org/issues/19333 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal ---------------------------------------- As it stands, Fiber Locals, Thread Locals and Fiber Storage have no way of deleting key-value associations. ```ruby 100.times do |i| name = :"variable-#{i}" Thread.current[name] = 10 end ``` Because of this, dynamically generated associations can leak over time. This is worse for things like Threads that might be pooled (or maybe an argument against user-space pooling). In any case, having a way to delete those associations would allow application code to at least delete the associations when they no longer make sense. I propose that assigning `nil` to "locals" or "storage" should effectively delete them. e.g. ```ruby 100.times do |i| name = :"variable-#{i}" Thread.current[name] = 10 Thread.current[name] = nil # delete association end ``` A more invasive alternative would be to define new interfaces like `Thread::Local`, `Fiber::Local` and `Fiber::Storage::Local` (or something) which correctly clean up on GC. -- https://bugs.ruby-lang.org/

3 9

[ruby-core:114590] [Ruby master Bug#19857] Eval coverage is reset after each `eval`.
by ioquatix (Samuel Williams) 06 Aug '25

06 Aug '25

Issue #19857 has been reported by ioquatix (Samuel Williams). ---------------------------------------- Bug #19857: Eval coverage is reset after each `eval`. https://bugs.ruby-lang.org/issues/19857 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal * Assignee: ioquatix (Samuel Williams) * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- It seems like `eval` based coverage is reset every time eval is invoked. ```ruby #!/usr/bin/env ruby require 'coverage' def measure(flag) c = Class.new c.class_eval(<<~RUBY, "foo.rb", 1) def foo(flag) if flag puts "foo" else puts "bar" end end RUBY return c.new.foo(flag) end Coverage.start(lines: true, eval: true) # Depending on the order of these two operations, different computation is calculated, because the evaluation of the code is considered different, even if the content/path is the same. measure(false) measure(true) p Coverage.result ``` Further investigation is required. -- https://bugs.ruby-lang.org/

4 20