From: zverok.offline@... Date: 2018-03-01T13:10:56+00:00 Subject: [ruby-core:85884] [Ruby trunk Feature#14564] `dig` opposite method Issue #14564 has been updated by zverok (Victor Shepelev). Was already proposed as a "bury" (direct antonym to `dig`) and rejected: https://bugs.ruby-lang.org/issues/11747 and https://bugs.ruby-lang.org/issues/13179 Matz's response: * "It's not clear to generate either Hash, Array, or Struct (or whatever) to bury a value. So it's better to reject now." to first and * "You have to come up with a better name candidate and concrete use-case." to second. BTW, you may be interested to take a look at my experimental [hm](https://github.com/zverok/hm) gem, which defines some declarative hash processing helpers, including `bury`. It, BTW, decides to generate Array on numeric bury key, and Hash on any other, but I understand that it could be too vague for some cases. ---------------------------------------- Feature #14564: `dig` opposite method https://bugs.ruby-lang.org/issues/14564#change-70739 * Author: nilcolor (Aleksey Blinov) * Status: Open * Priority: Normal * Assignee: * Target version: ---------------------------------------- We have nice `dig` method that helps a lot. Though we didn't have an opposite method that allows setting a value. I know we already have these: https://bugs.ruby-lang.org/issues/11747 https://bugs.ruby-lang.org/issues/13179 Both were closed because of name or lack of use cases. Let me promote the new name for this: ~~~ ruby class Hash def expand(*where, value) where[0..-2].reduce(self) { |h, key| h[key] = h[key] || {} }[where[-1]] = value self end end {}.expand(:a, :b, :c, 42) # => {:a=>{:b=>{:c=>42}}} {}.expand(:a, 0, :c, 42) # => {:a=>{0=>{:c=>42}}} {a: {}}.expand(:a, :b, :c, 42) # => {:a=>{:b=>{:c=>42}}} {a: {b: nil}}.expand(:a, :b, :c, 42) # => {:a=>{:b=>{:c=>42}}} {a: {foo: "bar"}}.expand(:a, :b, :c, 42) # => {:a=>{:foo=>"bar", :b=>{:c=>42}}} {a: {b: "wat"}}.expand(:a, :b, :c, 42) # => TypeError: no implicit conversion of Symbol into Integer class Array def expand(*where, value) where[0..-2].reduce(self) { |a, idx| a[idx] = a[idx] || [] }[where[-1]] = value self end end [].expand(2, 1, 3, "?") # => [nil, nil, [nil, [nil, nil, nil, "?"]]] [1, [0, 2], []].expand(1, 1, "BAM") # => [1, [0, "BAM"], []] [1, [0, 2], []].expand(2, 0, "BAM") # => [1, [0, 2], ["BAM"]] ~~~ Use cases: working with deeply nested structures, used as parameters (`params[:a][:nested][:some_id] = 42`). In general, I think it's mostly useful for Hashes. Though having this on Array may be useful as well. -- https://bugs.ruby-lang.org/ Unsubscribe: