Issue #16379 has been updated by jonathanhefner (Jonathan Hefner).


Eregon (Benoit Daloze) wrote:
> I've heard quite a few people saying that backporting `...` to Ruby 2.4-2.6 would be a good way to do migration for keyword arguments.

To me, as a gem maintainer, this sounds like the most appealing option.  But I understand that for the Ruby maintainers this is probably the least appealing option.

> If we don't want to backport `...`, there is also the option to use `pass_keywords` like so ...
> I think both of these are easier to understand than `ruby2_keywords`, and both don't need to have any performance trade-off on unrelated code (#16188).

For those reasons I agree that `pass_keywords`, as presented, seems preferable to `ruby2_keywords`.  Though I don't know enough about Ruby internals to criticize it.

jeremyevans0 (Jeremy Evans) wrote:
> For one, not everyone runs on the latest tiny release, and having different feature sets in tiny versions is likely to lead to user confusion.

This is a good point.

Has anyone proposed implementing `pass_keywords` as a pragma comment?  Doing so would avoid the need for a no-op definition, whether via backport or extra compatibility gem.


----------------------------------------
Feature #16379: Backporting ... to Ruby 2.4 - 2.6 and pass_keywords
https://bugs.ruby-lang.org/issues/16379#change-83008

* Author: Eregon (Benoit Daloze)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I've heard quite a few people saying that backporting `...` to Ruby 2.4-2.6 would be a good way to do migration for keyword arguments.
In fact, if we have `...` in Ruby 2.4+, I think `...` could be the way to do 90%+ of delegation in a backward-compatible way, and would be vastly more elegant than a hidden Hash flag (`ruby2_keywords`).

What does the Ruby core team think about that?

I think `...` works nicely for lexical delegation:
```ruby
def delegate(...)
  target(...)
end
```

It can also work for delegating in a separate method by using `...` inside a block inside the method accepting `...`:
https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html#pass_keywords
```ruby
def initialize(...)
  @call_later = -> { target(...) }
end

def call
  @call_later.call
end
```

---

If we don't want to backport `...`, there is also the option to use `pass_keywords` like so:
```ruby
pass_keywords def delegate(*args, &block)
  target(*args, &block)
end
```

```ruby
pass_keywords def initialize(*args, &block)
  @call_later = -> { target(*args, &block) }
end

def call
  @call_later.call
end
```

Which can easily work by making `pass_keywords` a no-op on Ruby <= 2.6 and make `*args` behave like `...` on Ruby 2.7+.

---

I think both of these are easier to understand than `ruby2_keywords`, and both don't need to have any performance trade-off on unrelated code (#16188).

I'd like to have the opinion of the core team on this.
It has been suggested multiple times (notably in my blog post on 10 November), but I have not seen any opinion on this tracker about it.



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>