Project

General

Profile

Actions

Feature #18617

open

Allow multiples keys in Hash#[] acting like Hash#dig

Added by ddfznt (Ederson Fuzinato) 4 months ago. Updated 4 months ago.

Status:
Open
Priority:
Normal
Assignee:
-
Target version:
-
[ruby-core:107799]

Description

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

Actions #1

Updated by hsbt (Hiroshi SHIBATA) 4 months ago

  • Description updated (diff)

Updated by janosch-x (Janosch Müller) 4 months ago

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

Updated by Eregon (Benoit Daloze) 4 months ago

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).

Actions

Also available in: Atom PDF