Issue #21545 has been updated by herwin (Herwin W). Maybe I'm reading too much into the examples, but this looks to me like something where pattern matching would be more suitable: ```ruby def match(input) case input in { status: { code: Integer => status } } puts "Status code: #{status}" in { status: status } puts "Other status: #{status}" else raise "mismatch: #{input}" end end match({ status: "ok" }) match({ status: { code: 200 } }) ``` Output: ``` Other status: ok Status code: 200 ``` ---------------------------------------- Feature #21545: #try_dig, a dig that returns early if it cannot dig deeper https://bugs.ruby-lang.org/issues/21545#change-114373 * Author: cb341 (Daniel Bengl) * Status: Open ---------------------------------------- Ruby offers `dig` for traversing nested hashes and arrays. It is strict and will raise if an intermediary object does not support `dig`. In many cases we only want to attempt the lookup and return `nil` if it cannot be followed, without caring about the exact reason. **Example:** ```rb { a: "foo" }.dig(:a, :b) # TypeError: String does not have #dig method { a: "foo" }.try_dig(:a, :b) # => nil ``` This is especially useful when dealing with data from APIs or other inconsistent sources: ```rb api_response = { status: "ok" } api_response.try_dig(:status, :code) # => nil api_response = { status: { code: 200 } } api_response.try_dig(:status, :code) # => 200 ``` The name `try_dig` makes it clear that it behaves like `dig` but will never raise for structural mismatches. It complements `dig` and the proposed `dig!` ([#12282](https://bugs.ruby-lang.org/issues/12282), [#15563](https://bugs.ruby-lang.org/issues/15563)) by covering the tolerant lookup case. A possible sketch: ```rb class Object def try_dig(*path) current = self path.each do |key| return nil unless current.respond_to?(:dig) begin current = current.dig(key) rescue StandardError return nil end end current end end ``` _I initially proposed this in Ruby core ([PR #14203](https://github.com/ruby/ruby/pull/14203)) and even implemented it in C, but later realized that if this gets introduced at all it probably makes more sense to have it in ActiveSupport rather than in core Ruby._ **Advantages** - Simplifies tolerant lookups without repetitive rescue logic - Clear intent when the value is optional - Useful for working with inconsistent or partially known data structures - Complements `dig` and potential `dig!` by covering the tolerant case **Disatvantages** - May hide structural issues that should be noticed during development -- https://bugs.ruby-lang.org/