https://bugs.ruby-lang.org/https://bugs.ruby-lang.org/favicon.ico?17097754782018-03-01T12:55:46ZRuby Issue Tracking SystemRuby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=707382018-03-01T12:55:46Zshevegen (Robert A. Heiler)shevegen@gmail.com
<ul></ul><p>I have nothing against the functionality, but I think the name .expand()<br>
is not a good one. When I read .expand, I think of the opposite of<br>
flatten; or it reminds me of .extend.</p>
<p>I don't have a better name suggestion myself, though.</p> Ruby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=707392018-03-01T13:10:54Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p>Was already proposed as a "bury" (direct antonym to <code>dig</code>) and rejected: <a href="https://bugs.ruby-lang.org/issues/11747" class="external">https://bugs.ruby-lang.org/issues/11747</a> and <a href="https://bugs.ruby-lang.org/issues/13179" class="external">https://bugs.ruby-lang.org/issues/13179</a></p>
<p>Matz's response:</p>
<ul>
<li>"It's not clear to generate either Hash, Array, or Struct (or whatever) to bury a value.<br>
So it's better to reject now." to first and</li>
<li>"You have to come up with a better name candidate and concrete use-case." to second.</li>
</ul>
<p>BTW, you may be interested to take a look at my experimental <a href="https://github.com/zverok/hm" class="external">hm</a> gem, which defines some declarative hash processing helpers, including <code>bury</code>. 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.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Hm</span><span class="p">({</span><span class="ss">a: </span><span class="p">{</span><span class="ss">foo: </span><span class="s2">"bar"</span><span class="p">}}).</span><span class="nf">bury</span><span class="p">(</span><span class="ss">:a</span><span class="p">,</span> <span class="ss">:b</span><span class="p">,</span> <span class="ss">:c</span><span class="p">,</span> <span class="mi">42</span><span class="p">).</span><span class="nf">to_h</span>
<span class="c1"># => {:a=>{:foo=>"bar", :b=>{:c=>42}}} </span>
<span class="no">Hm</span><span class="p">({</span><span class="ss">a: </span><span class="p">{</span><span class="ss">b: </span><span class="s2">"wat"</span><span class="p">}}).</span><span class="nf">bury</span><span class="p">(</span><span class="ss">:a</span><span class="p">,</span> <span class="ss">:b</span><span class="p">,</span> <span class="ss">:c</span><span class="p">,</span> <span class="mi">42</span><span class="p">).</span><span class="nf">to_h</span>
<span class="c1"># TypeError: String is not diggable</span>
<span class="no">Hm</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[]]).</span><span class="nf">bury</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="s2">"BAM"</span><span class="p">).</span><span class="nf">to_h</span> <span class="c1"># well, to_h is weird here, but works</span>
<span class="c1"># => [1, [0, 2], ["BAM"]]</span>
<span class="no">Hm</span><span class="p">([]).</span><span class="nf">bury</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s2">"?"</span><span class="p">).</span><span class="nf">to_h</span>
<span class="c1"># => [nil, nil, [nil, [nil, nil, nil, "?"]]] </span>
</code></pre> Ruby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=708482018-03-07T17:29:30Znilcolor (Aleksey Blinov)
<ul></ul><p>I know about those 2 proposals. I references them in the description )</p>
<p>Name is a hard topic. As for types - I'd say that having same type as a receiver is enough.<br>
So, <code>{}.whatever_name(*)</code> will generate nested Hashes. <code>[].whatever_name(*)</code> - Arrays. This will cover the majority of cases.</p>
<p>Names... Personally, I find <code>bury</code> nice ) Though a bit of horrory. <code>expand</code> - yeah, maybe not that good.</p>
<p>What about "ruin", "embed", or "melt"?</p> Ruby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=708512018-03-07T23:24:58Zphluid61 (Matthew Kerwin)matthew@kerwin.net.au
<ul></ul><p>Clearly the only accurate name for this method is <code>store_recursive_with_autovivification</code></p>
<p>A lot of people ask for it, but I still can't see how this is a good thing to add to the language. In your personal code, sure -- maybe even in a gem -- but not the core.</p> Ruby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=983332022-07-12T18:10:01Zprofessor (Todd Sedano)
<ul></ul><p>Often my team needs to modify deep hash structures and we created another implementation of the <code>bury</code> method.</p>
<p>We suggested our code as a modification to Hash in ActiveSupport <a href="https://github.com/rails/rails/pull/45562" class="external">PR</a>. First, we wanted to verify that the ruby language does not want a <code>bury</code> method on a Hash.</p>
<p>I find the code in our PR easier to understand than the implementation suggested in this issue 14564 and in <a href="https://bugs.ruby-lang.org/issues/13179" class="external">13179</a>.</p> Ruby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=983362022-07-13T16:00:02Zchrisseaton (Chris Seaton)chris@chrisseaton.com
<ul></ul><p>Instead of different <code>dig</code> and <code>bury</code> tools, a 'lens' abstraction could combine the two.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">deep_hash</span> <span class="o">=</span> <span class="p">{</span><span class="ss">a: </span><span class="p">{</span><span class="ss">b: </span><span class="p">{</span><span class="ss">c: </span><span class="p">{</span><span class="ss">d: </span><span class="mi">100</span><span class="p">}}}}</span>
<span class="nb">p</span> <span class="n">deep_hash</span><span class="p">.</span><span class="nf">dig</span><span class="p">(</span><span class="ss">:a</span><span class="p">,</span> <span class="ss">:b</span><span class="p">,</span> <span class="ss">:c</span><span class="p">,</span> <span class="ss">:d</span><span class="p">)</span>
<span class="k">class</span> <span class="nc">Lens</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">lens</span><span class="p">(</span><span class="o">*</span><span class="n">keys</span><span class="p">)</span>
<span class="n">lens</span> <span class="o">=</span> <span class="no">Leaf</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">keys</span><span class="p">.</span><span class="nf">pop</span><span class="p">)</span>
<span class="n">lens</span> <span class="o">=</span> <span class="no">Node</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">keys</span><span class="p">.</span><span class="nf">pop</span><span class="p">,</span> <span class="n">lens</span><span class="p">)</span> <span class="k">until</span> <span class="n">keys</span><span class="p">.</span><span class="nf">empty?</span>
<span class="n">lens</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Node</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">child</span><span class="p">)</span>
<span class="vi">@key</span> <span class="o">=</span> <span class="n">key</span>
<span class="vi">@child</span> <span class="o">=</span> <span class="n">child</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">get</span><span class="p">(</span><span class="n">object</span><span class="p">)</span>
<span class="vi">@child</span><span class="p">.</span><span class="nf">get</span> <span class="n">object</span><span class="p">[</span><span class="vi">@key</span><span class="p">]</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">set</span><span class="p">(</span><span class="n">object</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="vi">@child</span><span class="p">.</span><span class="nf">set</span> <span class="n">object</span><span class="p">[</span><span class="vi">@key</span><span class="p">],</span> <span class="n">value</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Leaf</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
<span class="vi">@key</span> <span class="o">=</span> <span class="n">key</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">get</span><span class="p">(</span><span class="n">object</span><span class="p">)</span>
<span class="n">object</span><span class="p">[</span><span class="vi">@key</span><span class="p">]</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">set</span><span class="p">(</span><span class="n">object</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="n">object</span><span class="p">[</span><span class="vi">@key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">lens</span> <span class="o">=</span> <span class="no">Lens</span><span class="p">.</span><span class="nf">lens</span><span class="p">(</span><span class="ss">:a</span><span class="p">,</span> <span class="ss">:b</span><span class="p">,</span> <span class="ss">:c</span><span class="p">,</span> <span class="ss">:d</span><span class="p">)</span>
<span class="nb">p</span> <span class="n">lens</span><span class="p">.</span><span class="nf">get</span><span class="p">(</span><span class="n">deep_hash</span><span class="p">)</span>
<span class="n">lens</span><span class="p">.</span><span class="nf">set</span> <span class="n">deep_hash</span><span class="p">,</span> <span class="mi">14</span>
<span class="nb">p</span> <span class="n">lens</span><span class="p">.</span><span class="nf">get</span><span class="p">(</span><span class="n">deep_hash</span><span class="p">)</span>
</code></pre> Ruby master - Feature #14564: `dig` opposite methodhttps://bugs.ruby-lang.org/issues/14564?journal_id=1033542023-05-30T22:04:56Zbyroot (Jean Boussier)byroot@ruby-lang.org
<ul><li><strong>Related to</strong> <i><a class="issue tracker-2 status-5 priority-4 priority-default closed" href="/issues/19699">Feature #19699</a>: Need a way to store values like dig</i> added</li></ul>