[ruby-core:97225] [Ruby master Bug#16643] Array#dig converts keywords to positional hash

Issue #16643 has been updated by Dan0042 (Daniel DeLorme).


Are you seriously telling me that you consider it normal and correct that `obj.dig(**kw)` is _not_ equivalent to `[obj].dig(0, **kw)` ???

I will note that your first example produces `2` whether keywords are passed with RB_PASS_CALLED_KEYWORDS or not.

And your second example produces `{{:c=>1}=>2}` (in 2.6 also) whether keywords are passed with RB_PASS_CALLED_KEYWORDS or not; the only difference is the warning. The reason it produces the "incorrect" result is because the method is buggy, not because the method uses keywords. If you capture the keywords and then throw them away of course the result is incorrect. It should have been something like this:

```ruby
a = Object.new
def a.dig(arg, *args, **kw)
  obj = send(arg)
  return obj if args.empty? and kw.empty?
  obj.dig(*args, **kw)
end
def a.b
  [{{c: 1}=>2}]
end
[[a]].dig(0, 0, :b, 0, c: 1)
# keyword argument warning in 2.7.0
# 2
```

And ideally if you want `{c: 1}` to be used as one of the keys in the (positional) dig chain, it should have been written as `{c: 1}`, not as a keyword.

I sort of understand your point, that dig is _not supposed_ to accept keyword arguments. And in that case auto-converting to a positional hash makes no difference. But in that case passing it as keywords would also have the same behavior **and** it would preserve the positional/keyword separation. And you never know, maybe someone will want to use keywords in their custom dig method. Just a thought experiment:

```ruby
a = Object.new
def a.dig(m, *args, base: nil, **kw)
  respond_to?(m) or return nil
  obj = send(m, base) or return nil
  return obj if args.empty?
  obj.dig(*args, **kw)
end
def a.foo(base=nil)
  [42.to_s(base || 10)]
end
[[a]].dig(0, 0, :foo, 0, base: 13)
# "33"
```


----------------------------------------
Bug #16643: Array#dig converts keywords to positional hash
https://bugs.ruby-lang.org/issues/16643#change-84335

* Author: Dan0042 (Daniel DeLorme)
* Status: Rejected
* Priority: Normal
* ruby -v: ruby 2.7.0p0 (2019-12-25 revision a65e8644fb) [x86_64-linux]
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
The following behavior for `dig` looks very weird to me:

```ruby
o=Object.new
def o.dig(**kw) p [kw] end
o.dig(x:1)     
#no warning
#[{:x=>1}]
[o].dig(0, x:1)
#warning: Using the last argument as keyword parameters is deprecated
#[{:x=>1}]

o=Object.new
def o.dig(a, **kw) p [a,kw] end
o.dig(x:1)
#warning: Passing the keyword argument as the last hash parameter is deprecated
#[{:x=>1}, {}]
[o].dig(0, x:1)
#no warning
#[{:x=>1}, {}]
```

So the keywords are interpreted as a positional hash, resulting in the opposite of the behavior I would expect.

This would be easy to fix by changing `rb_obj_dig` to use 

```
        return rb_check_funcall_with_hook_kw(obj, id_dig, argc, argv,
                                             no_dig_method, obj,
                                             RB_PASS_CALLED_KEYWORDS);
```

What this just an oversight? I can't think of a rationale for the current behavior.




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

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