From: merch-redmine@... Date: 2020-02-20T20:55:23+00:00 Subject: [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: