Ruby

Eregon (Benoit Daloze) wrote:

$ ruby -ve '{a: 1}.each_pair { |a, kw: :def| p [a,kw] }' ruby 3.0.0dev (2020-09-18T09:12:58Z master e1cca08a6d) [x86_64-linux] [:a, :def] # bug, should be [[1, 2], :def] $ ruby -ve '{a: 1}.each_pair { |a, **kw| p [a,kw] }' ruby 3.0.0dev (2020-09-18T09:12:58Z master e1cca08a6d) [x86_64-linux] [:a, {}] # bug, should be [[1, 2], {}] 

So the value of the key-value pair is lost and not assigned to any argument.

This seems a general problem of Proc, not just #each_pair:

$ ruby -e 'proc { |a, kw: :def| p [a,kw] }.call(1,2)' [1, :def] # understandable $ ruby -e 'proc { |a, kw: :def| p [a,kw] }.call([1,2])' [1, :def] # bug, should be [[1, 2], :def] $ ruby -e 'proc { |a, **kw| p [a,kw] }.call(1,2)' [1, {}] # understandable $ ruby -e 'proc { |a, **kw| p [a,kw] }.call([1,2])' [1, {}] # bug, should be [[1, 2], {}] 

Are we sure this is a bug, and not just the result of a different behavior of proc{|a|} proc{|a,|}, with keywords being treated like the latter (autosplatting) as a comma is used?

Keywords in procs have always caused autosplatting of the proc. With Ruby 3, we could change this if there were only a single argument and keywords, but it seems more like a new feature than a bug fix.

Is there a reason that keywords in procs cause autosplatting?
It seems counter-intuitive.
I would expect autosplatting depends on declared positional parameters only.

I'd argue it's a bug, because we lose part of the arguments for seemingly no reason.

Also keyword extension is supposed to be safe, right? Here it loses part of the arguments, which seems rather severe to me:
proc { |a| p [a] }.call([1,2,3]) # => [[1, 2, 3]]
proc { |a, **kw| p [a,kw] }.call([1,2,3]) # => [1, {}] (where are 2 and 3??)
proc { |a,| p [a] }.call([1,2,3]) # => [1] this is OK, I'm explicitly discarding extra arguments.

Eregon (Benoit Daloze) wrote in #note-2:

Is there a reason that keywords in procs cause autosplatting?
It seems counter-intuitive.
I would expect autosplatting depends on declared positional parameters only.

Previously, the autosplatted argument could be used as keywords if they were a hash or implicitly convertible to a hash, though this is no longer true in Ruby 3.

I'd argue it's a bug, because we lose part of the arguments for seemingly no reason.

Also keyword extension is supposed to be safe, right? Here it loses part of the arguments, which seems rather severe to me:
proc { |a| p [a] }.call([1,2,3]) # => [[1, 2, 3]]
proc { |a, **kw| p [a,kw] }.call([1,2,3]) # => [1, {}] (where are 2 and 3??)
proc { |a,| p [a] }.call([1,2,3]) # => [1] this is OK, I'm explicitly discarding extra arguments.

I agree that your suggested behavior makes more intuitive sense with Ruby 3 semantics, but not with Ruby 2 semantics. I'm not sure the loss of backwards compatibility is worth it, and this will break backwards compatibility. This is something @matz (Yukihiro Matsumoto) should decide.