[#107867] Fwd: [ruby-cvs:91197] 8f59482f5d (master): add some tests for Unicode Version 14.0.0 — Martin J. Dürst <duerst@...>
To everybody taking care of continuous integration:
3 messages
2022/03/13
[#108090] [Ruby master Bug#18666] No rule to make target 'yaml/yaml.h', needed by 'api.o' — duerst <noreply@...>
Issue #18666 has been reported by duerst (Martin D端rst).
7 messages
2022/03/28
[#108117] [Ruby master Feature#18668] Merge `io-nonblock` gems into core — "Eregon (Benoit Daloze)" <noreply@...>
Issue #18668 has been reported by Eregon (Benoit Daloze).
22 messages
2022/03/30
[ruby-core:107817] [Ruby master Feature#18617] Allow multiples keys in Hash#[] acting like Hash#dig
From:
janosch-x <noreply@...>
Date:
2022-03-10 08:31:38 UTC
List:
ruby-core #107817
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:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>