Issue #18773 has been updated by Eregon (Benoit Daloze). The implementation of pattern matching needs to read at indices from the return value of `deconstruct`, but `Enumerable` doesn't have `[]` or `at` or anything like that. So I think it is difficult to support and could very well end up making pattern matching slower. There is a similar issue in the issue description, it would prevent caching the result of `deconstruct`, as already pointed out. I think pattern shouldn't do too crazy things (like calling `each` with a block behind the scenes), I think simple is good. ---------------------------------------- Feature #18773: deconstruct to receive a range https://bugs.ruby-lang.org/issues/18773#change-108739 * Author: kddnewton (Kevin Newton) * Status: Rejected * Assignee: ktsj (Kazuki Tsujimoto) ---------------------------------------- Currently when you're pattern matching against a hash pattern, `deconstruct_keys` receives the keys that are being matched. This is really useful for computing expensive hashes. However, when you're pattern matching against an array pattern, you don't receive any information. So if the array is expensive to compute (for instance loading an array of database records), you have no way to bail out. It would be useful to receive a range signifying how many records the pattern is specifying. It would be used like the following: ```ruby class ActiveRecord::Relation def deconstruct(range) (loaded? || range.cover?(count)) ? records : nil end end ``` It needs to be a range and not just a number to handle cases where `*` is used. You would use it like: ```ruby case Person.all in [] "No records" in [person] "Only #{person.name}" else "Multiple people" end ``` In this way, you wouldn't have to load the whole thing into memory to check if it pattern matched. The patch is here: https://github.com/ruby/ruby/pull/5905. -- https://bugs.ruby-lang.org/