From: janosch-x <noreply@...>
Date: 2022-03-10T08:31:38+00:00
Subject: [ruby-core:107817] [Ruby master Feature#18617] Allow multiples keys in Hash#[] acting like Hash#dig

Issue #18617 has been updated by janosch-x (Janosch M��ller).


i think this would be confusing.

- its not obvious what `hash[:a, :b]` does, it could also mean `hash.values_at(:a, :b)`
- no other bracket method on data structures behaves this way, e.g.
  - `Array#[]` (and this can't be changed without breaking current 2-argument usage)
  - `Hash.[]`
  - `Set.[]`
  - `Struct#[]`

----------------------------------------
Feature #18617: Allow multiples keys in Hash#[] acting like Hash#dig
https://bugs.ruby-lang.org/issues/18617#change-96747

* Author: ddfznt (Ederson Fuzinato)
* Status: Open
* Priority: Normal
----------------------------------------
# Abstract

Since is very common the hash nested hashes, expecialy in the API world, I whold love to use Hash#[] syntax as alias for Hash#dig.

# Background

Since a start to learn ruby, Hashes are the most powerful structure I can use to build API. It's intuitive and concise way to represent data.
But something always make me unconfortable, the excess of square brackets([]) to access nested data.
Everytime is a "nasty", to access things like 
``` ruby
purchase[:customer][:addresses][:delivery][:street]
```
even worse when data is missing anypoint.
So, I meet the Hash#dig. Wonderful, easy, and powerful as well.

But .dig is not so intuitive, and I think, why not use the most common way to access data with multiple keys. 
Why not use the most powerful method, with all powerfulness.
Why limitate Hash#[] to one single param. :( 

# Proposal

So, my proposal is to allow Hash#[] to take undefinily params, and act like .dig, more concise to access nested data, more powerful, more happy :D.

**Stop:**
``` ruby
hash[:a][:b][:c][:d][:e][:f][:u]
``` 

**Just:**

``` ruby
hash[:a, :b, :c, :d, :e, :lov, :u]
``` 

# Implementation

Since Hash#[] and Hash.dig, both calling Hash::new when key is not found, just check the arity for performance.
Currently, I use something like:

``` ruby
module AwesoneAccess
  def [] *keys
    if keys.many?
      dig *keys
    else
      super
    end
  end
end

class Hash
  prepend AwesoneAccess
end

a = {foo: {bar: :baz}} # => { foo: { bar: :baz }

a[:foo][:bar] == a[:foo, :bar] # => true
```
 

# Evaluation

It'll be awesome. (������������)���*:��������� ���������: *���(������������)

# Discussion

I would love listen you guys.
Sincerely...���_���

# Summary

Faces by [[textfac.es]] ?!






-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>