[ruby-core:85981] [Ruby trunk Feature#14564] `dig` opposite method

Issue #14564 has been updated by nilcolor (Aleksey Blinov).


I know about those 2 proposals. I references them in the description )

Name is a hard topic. As for types - I'd say that having same type as a receiver is enough.
So, `{}.whatever_name(*)` will generate nested Hashes. `[].whatever_name(*)` - Arrays. This will cover the majority of cases.

Names... Personally, I find `bury` nice ) Though a bit of horrory. `expand` - yeah, maybe not that good.

What about "ruin", "embed", or "melt"?

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

* 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: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>