Issue #22097 has been updated by shugo (Shugo Maeda). Status changed from Open to Assigned Assignee set to shugo (Shugo Maeda) matz (Yukihiro Matsumoto) wrote in #note-19:
I suggest `Proc#refined(mod, ...)`. It is short, and the past participle cannot be read as a command: `original.refined(StringExt)` can only mean "a refined version of the original", so the copying semantics are built into the word form itself. `Enumerable#lazy` is a precedent for an adjective-like name returning a derived object.
@shugo, if `refined` sounds acceptable to you, let's go with it.
Thank you, I agree. I have renamed the method in both implementations: * CRuby: https://github.com/ruby/ruby/pull/17248 * JRuby: https://github.com/jruby/jruby/pull/9486 While updating the implementations, I also made one semantic change that I would like to note here: calling `using` inside the body of a refined Proc now raises RuntimeError. This applies to the proc body itself, to nested blocks, and to class/module bodies opened inside it, including when the proc is passed to `module_eval`. The reason is that the refinement set of a refined Proc is fixed when `refined` is called. Internally, procs created from the same block with the same modules share a single copied instruction sequence and its method-resolution caches, and that sharing is only sound while all of them run under exactly the same refinement set. A `using` in mid-body would change the set for one proc at runtime and leak the newly activated refinements to its siblings through the shared caches. Pass all modules in a single `refined()` call instead. `Module#refine` itself (which only defines refinements without activating them) remains allowed inside the body. Two smaller updates since #note-16: * `Proc#refined` can be called on any Ractor, and the memoized copy is now Ractor-shareable (the refinement table is frozen at creation), so the cache also works across Ractors. * Calling `refined` on the same block with different module sets evicts the single-entry cache; this now emits a `:performance`-category warning (disabled by default, like other performance warnings). If there are no further concerns, I will proceed with `Proc#refined`. ---------------------------------------- Feature #22097: Add Proc#with_refinements https://bugs.ruby-lang.org/issues/22097#change-118041 * Author: shugo (Shugo Maeda) * Status: Assigned * Assignee: shugo (Shugo Maeda) ---------------------------------------- ## Abstract I propose `Proc#with_refinements(mod, ...)` to support block-level refinements. ```ruby module StringExt refine String do def shout = upcase + "!" end end original = ->(s) { s.shout } refined = original.with_refinements(StringExt) p refined.call("hello") # "HELLO!" p original.call("hello") # NoMethodError ``` When no argument is given, `ArgumentError` is raised. When a non-`Module` argument is given, `TypeError` is raised. ## Background and Motivation I previously proposed `Proc#using` in [Feature #16461], but it introduced semantic complexities because it mutated existing blocks. Instead of mutating the existing block, `Proc#with_refinements` returns a new `Proc` object with its own isolated call sites. This approach makes its semantics much simpler than `Proc#using`, and it avoids thread-safety issues and plays nicely with inline caches. ## Use Cases `Proc#with_refinements` is useful to implement internal DSLs applying refinements implicitly. * [activerecord-refinements](https://github.com/shugo/activerecord-refinements/blob/8869717fcba96fae3965d...) * DSL for SQL * Example: `User.where { :name == 'matz' }` * [radd_djur](https://github.com/shugo/radd_djur/blob/proc-with_refinements/lib/radd_djur/...) * DSL for monadic parser combinators ## Limitations * Similar to `Proc#binding`, `Proc#with_refinements` raises `ArgumentError` if the receiver is not created from a Ruby block. ```ruby :to_s.to_proc.with_refinements(StringExt) #=> ArgumentError ``` * Chained application of `Proc#with_refinements` is not allowed. `ArgumentError` is raised if the receiver is a `Proc` returned by `Proc#with_refinements`. ```ruby refined = prc.with_refinements(StringExt) refined.with_refinements(IntegerExt) #=> ArgumentError ``` * `define_method` (and `define_singleton_method`) rejects a `Proc` with refinements. `ArgumentError` is raised if the return value of `Proc#with_refinements` is given to `define_method`. ```ruby refined = prc.with_refinements(StringExt) define_method(:foo, &refined) #=> ArgumentError ``` ## Implementation I've opened a pull request: https://github.com/ruby/ruby/pull/17248 A PoC for JRuby is also available at: https://github.com/jruby/jruby/pull/9486 ### Data structure changes * Added a bit field `has_refinements` to `rb_proc_t`. * Added a hidden instance variable to `Proc` to store a `cref` with the applied refinements. * Added a single-entry cache `refinement_memo` to `rb_iseq_constant_body`. ### Deep copy of iseq and caching `Proc#with_refinements` performs a deep copy of the receiver's `iseq` to isolate its call sites from the original `Proc`. While a deep copy can be an expensive operation, the single-entry cache in `rb_iseq_constant_body` mitigates this overhead effectively for most practical use cases where the same refinements are applied repeatedly. ### Overhead for code not using Proc#with_refinements * Memory footprint: Neither internal structure grows in size. `has_refinements` is a 1-bit field added to rb_proc_t's existing bit field, and `refinement_memo` shares a union with `mandatory_only_iseq` in rb_iseq_constant_body. * Execution speed: The common `Proc#call` path is kept frameless and only adds a single `has_refinements` bit check. * GC: The mark/free/memsize functions add a single branch per `iseq` to select the union member. Benchmark results: https://gist.github.com/shugo/ddfe92f28ea31e6527a2f270e6daee7c Here's an excerpt from the results, where `compare-ruby` is master and `built-ruby` is the branch for this feature (focusing on Proc/Block operations): | |compare-ruby|built-ruby| |:------------------------------------|-----------:|---------:| |vm_proc | 47.215M| 46.149M| | | 1.02x| -| |vm_yield | 1.649| 1.754| | | -| 1.06x| -- https://bugs.ruby-lang.org/