From: "osyoyu (Daisuke Aritomo) via ruby-core" <ruby-core@...>
Date: 2025-12-08T03:04:04+00:00
Subject: [ruby-core:124051] [Ruby Feature#21767] Consider procs which `self` is Ractor-shareable as Ractor shareable

Issue #21767 has been reported by osyoyu (Daisuke Aritomo).

----------------------------------------
Feature #21767: Consider procs which `self` is Ractor-shareable as Ractor shareable
https://bugs.ruby-lang.org/issues/21767

* Author: osyoyu (Daisuke Aritomo)
* Status: Open
----------------------------------------
I would like to allow procs which `self` is Ractor-shareable to be automatically eligible as shareable, without an explicit `Ractor.make_shareable` call.

```ruby
class C
  PROC = proc { p ARRAY }.freeze
end

Ractor.new { C::PROC.call }.value # Allow this, since `C` is shareable
```

Proposal is: Consider procs/lambdas which meet the following condition as Ractor-shareable.

- The proc is frozen.
- The proc's `self` is shareable.

This proposal is has taken inspiration from #21033 .

## Usecase

The main usecase in mind is procs/lambdas in class-level constants. Some libraries store procs in constants as a convenient place for library-wide logic. Those procs usually do not access unshareable state, thus conceptually safe to be shared across Ractors. However, the current limitation completely blocks this.

Examples may be found in ruby/ruby, and I have submitted a pull request to migrate one to `Ractor.shareable_proc`.

```ruby
class Pathname
  SAME_PATHS = if File::FNM_SYSCASE.nonzero?
    # Avoid #zero? here because #casecmp can return nil.
    proc {|a, b| a.casecmp(b) == 0}
  else
    proc {|a, b| a == b}
  end
end
```

https://github.com/search?q=repo%3Aruby%2Fruby%20%2F(%3F-i)%5BA-Z%5D%20%3D%20(proc%7Clambda)%2F&type=code

More examples can be found in public code.

https://github.com/search?q=language%3Aruby+%2F%28%3F-i%29%5BA-Z%5D+%3D+%28proc%7Clambda%29%2F&type=code

It can be observed that a good portion of these do not access unshareable state.

Appending `.freeze` would be much more acceptable than redefining using `Ractor.shareable_proc`, which is a Ruby 4.0-only feature.

## Discussion: Change of behavior when illegal access occurs in proc

Consider this code. The proc accesses non-frozen `C::ARRAY`, which is against the rules of Ractors regardless of this patch.

```ruby
class C
  ARRAY = []
  PROC = proc { p ARRAY }
end

# Still illegal since C::ARRAY is not shareable
Ractor.new { C::PROC.call }.value
```

This code used to raise on `C::PROC.call` (`can not access non-shareable objects in constant C::PROC by non-main Ractor.`). When this patch is applied, it will raise on `p ARRAY` (`can not access non-shareable objects in constant C::ARRAY by non-main ractor.`).

This could be debatable change. If this is not acceptable, I'd like to revisit #21033 .



-- 
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/lists/ruby-core.ml.ruby-lang.org/