Feature #18617: Allow multiples keys in Hash#[] acting like Hash#dig

• Status: Open
• Assignee: -
• Target version: -

[ddfznt (Ederson Fuzinato)]

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

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:

hash[:a][:b][:c][:d][:e][:f][:u]

Just:

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:

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]] ?!

[hsbt (Hiroshi SHIBATA)]

• Description updated (diff)

[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#[]

[Eregon (Benoit Daloze)]

janosch-x (Janosch Müller) wrote in #note-2:

i think this would be confusing.

Agreed. Also IMHO accessing deep chains with many potential nils should be explicit (i.e, using dig).