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

Issue #16643 has been updated by jeremyevans0 (Jeremy Evans).

Status changed from Open to Rejected

This behavior is deliberate.  `dig` should only be overridden if you want to be able to access objects stored inside the object.  dig should accept `*args`, using the first element to look inside the object, and passing the remaining arguments to `dig` on that object (or just returning that object if there are no remaining arguments).

The issue with trying to support keyword arguments in dig is that it would break cases where you are looking up objects via a hash.  For example, this code without keyword argument returns the expected output:

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

Using keyword arguments breaks things in 2.7, but you get a warning that behavior changes in 3.0:

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

Note that in Ruby 3.0, you get the expected value (2), even if you have dig accept keyword arguments, because the hash is passed as a positional argument and not keywords.

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

* 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>