[ruby-core:93096] [Ruby trunk Feature#15563] #dig that throws an exception if an key doesn't exist
From:
knu@...
Date:
2019-06-13 08:08:43 UTC
List:
ruby-core #93096
Issue #15563 has been updated by knu (Akinori MUSHA).
I thought adding an optional block to dig could be an idea.
```ruby
obj.dig(*keys) { |dug_keys, rest_keys|
# raise yourself or return something
}
```
But the costs required for extending the dig method as such in Array or Hash-like classes would be a bit too high.
----------------------------------------
Feature #15563: #dig that throws an exception if an key doesn't exist
https://bugs.ruby-lang.org/issues/15563#change-78518
* Author: 3limin4t0r (Johan Wentholt)
* Status: Open
* Priority: Normal
* Assignee:
* Target version:
----------------------------------------
Ruby 2.3.0 introduced `#dig` for *Array*, *Hash* and *Struct*. Both *Array* and *Hash* have `#fetch` which does the same as `#[]`, but instead of returning the default value an exception is raised (unless a second argument or block is given). *Hash* also has `#fetch_values` which does the same as `#values_at`, raising an exception if an key is missing. For `#dig` there is no such option.
My proposal is to add a method which does the same as `#dig`, but instead of using the `#[]` accessor it uses `#fetch`.
This method would look something like this:
```Ruby
module DigWithException
def dig_e(key, *others)
value = fetch(key)
return value if value.nil? || others.empty?
if value.respond_to?(__method__, true)
value.send(__method__, *others)
else
raise TypeError, "#{value.class} does not have ##{__method__} method"
end
end
end
Array.include(DigWithException)
Hash.include(DigWithException)
```
The exception raised is also taken from `#dig` (`[1].dig(0, 1) #=> TypeError: Integer does not have #dig method`). I personally have my issues with the name `#dig_e`, but I haven't found a better name yet.
There are also a few other things that I haven't thought out yet.
1. Should this method be able to accept a block which, will be passed to the `#fetch` call and recursive `#dig_e` calls?
```Ruby
module DigWithException
def dig_e(key, *others, &block)
value = fetch(key, &block)
return value if value.nil? || others.empty?
if value.respond_to?(__method__, true)
value.send(__method__, *others, &block)
else
raise TypeError, "#{value.class} does not have ##{__method__} method"
end
end
end
Array.include(DigWithException)
Hash.include(DigWithException)
```
2. I currently kept the code compatible with the `#dig` description.
> Extracts the nested value specified by the sequence of *key* objects by calling `dig` at each step, returning `nil` if any intermediate step is `nil`.
However, with this new version of the method one could consider dropping the *"returning `nil` if any intermediate step is `nil`"* part, since this would be the more strict version.
```Ruby
module DigWithException
def dig_e(key, *others)
value = fetch(key)
return value if others.empty?
if value.respond_to?(__method__, true)
value.send(__method__, *others)
else
raise TypeError, "#{value.class} does not have ##{__method__} method"
end
end
end
Array.include(DigWithException)
Hash.include(DigWithException)
```
I'm curious to hear what you guys think about the idea as a whole, the method name and the two points described above.
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>