[#109207] [Ruby master Feature#18915] New error class: NotImplementedYetError or scope change for NotImplementedYet — Quintasan <noreply@...>
Issue #18915 has been reported by Quintasan (Michał Zając).
18 messages
2022/07/14
[ruby-core:109133] [Ruby master Feature#18773] deconstruct to receive a range
From:
"nevans (Nicholas Evans)" <noreply@...>
Date:
2022-07-04 03:21:23 UTC
List:
ruby-core #109133
Issue #18773 has been updated by nevans (Nicholas Evans).
So here's another option: allow `deconstruct` to return an `Enumerable` (or duck-typed). Personally, I'd *much* rather write custom optimized versions of enumerable methods than write a complicated optimized `deconstruct` method. And if the methods to efficiently pattern match don't currently exist on `Enumerable`, perhaps they should be added? That way improvements to `Enumerable` can automatically become improvements to pattern matching and vice versa.
I was thinking something along the lines of:
* v1: short-circuit using `enum.size` then proceed with `enum.to_a` as the input
* v2: fill input array with only values that can potentially be used: `[*enum.first(pre.max), *enum.last(post.max)]`
_(This might require `Enumerable#last`. But we already have `#reverse_each`, and other O(n) or O(n lg n) methods, so why not `#last`?)_
* v3: use the enumerator directly (much more complicated than v1 and v2). enables lazy-loaded short-circuiting.
* enables find patterns to match against lazily fetched elements, and lazy loading for potential *but unlikely* pre & post args
* might require a caching proxy enumerator, or `Enumerator#next`,
or a new method like `split_at(idx) => [Enumerable => head, Enumerable => tail]`
* v4: handle unbounded/infinite sequences with *lazy-loaded rest vars*. This is maybe a crazy thing, but I think it could be very nice: allow `stream in [a, b, *rest]` to assign an *enumerable* to `rest`, which can then be used as a continuation.
----------------------------------------
Feature #18773: deconstruct to receive a range
https://bugs.ruby-lang.org/issues/18773#change-98274
* Author: kddeisz (Kevin Newton)
* Status: Assigned
* Priority: Normal
* 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/
Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>