Project

General

Profile

Bug #17178

Procs with kw:def/**kw lose elements when called with a single Array

Added by Eregon (Benoit Daloze) about 1 month ago. Updated 22 days ago.

Status:
Closed
Priority:
Normal
Target version:
-
ruby -v:
ruby 3.0.0dev (2020-09-18T09:12:58Z master e1cca08a6d) [x86_64-linux]
[ruby-core:100037]

Description

$ 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], {}]

Updated by jeremyevans0 (Jeremy Evans) about 1 month ago

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.

Updated by Eregon (Benoit Daloze) about 1 month ago

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.

Updated by jeremyevans0 (Jeremy Evans) about 1 month ago

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.

Updated by Eregon (Benoit Daloze) about 1 month ago

  • Assignee set to matz (Yukihiro Matsumoto)

jeremyevans0 (Jeremy Evans) wrote in #note-3:

I'm not sure the loss of backwards compatibility is worth it, and this will break backwards compatibility.

It would only break code that explicitly loses arguments that way, which I would think is never intended.
It's probably also quite rare to use any keyword arguments for blocks.
The fact we (AFAIK) did not have many bug reports about this before sounds to me like very few people ever run into this weird behavior.

Assigned to matz.

Updated by matz (Yukihiro Matsumoto) 22 days ago

  • Status changed from Open to Closed

I think it should be as it is. It would break compatibility from Ruby2.x. It's not that big issue worh breaking.

Matz.

Also available in: Atom PDF