[ruby-core:109192] [Ruby master Feature#14564] `dig` opposite method

Issue #14564 has been updated by professor (Todd Sedano).


Often my team needs to modify deep hash structures and we created another implementation of the `bury` method. 

We suggested our code as a modification to Hash in ActiveSupport [PR](https://github.com/rails/rails/pull/45562). First, we wanted to verify that the ruby language does not want a `bury` method on a Hash.

I find the code in our PR easier to understand than the implementation suggested in this issue 14564 and in [13179](https://bugs.ruby-lang.org/issues/13179).


----------------------------------------
Feature #14564: `dig` opposite method
https://bugs.ruby-lang.org/issues/14564#change-98333

* Author: nilcolor (Aleksey Blinov)
* Status: Open
* Priority: Normal
----------------------------------------
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: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>