From: "nevans (Nicholas Evans)" <noreply@...>
Date: 2022-07-04T03:07:09+00:00
Subject: [ruby-core:109132] [Ruby master Feature#18773] deconstruct to receive a range

Issue #18773 has been updated by nevans (Nicholas Evans).


@kddeisz If we want that second option to short-circuit on min size, we need to send `min` independently of `max_potential_pre_args` and `max_potential_post_args`.  E.g. we wouldn't want to accidentally return `nil` for this:

```ruby
# minmax_all_args:  1..
# minmax_pre_args:  3..4
# minmax_post_args: 2..1
# minmax_ary_ptrn:  5..   e.g. pre+post, if any rest args then max is unbounded
case obj
in [A,B,C,D,*,Z];   etc
in [A,B,C,*,Y,Z];   etc
in [*, {find:}, *]; etc
end
```

And if we want to return the smallest array containing all potentially used args, `[pre, *, post]` can return *only* pre and post elements... with a caveat: disambiguating between when the max args comes from a pattern without a rest-arg, but another pattern has a rest arg.  E.g. `case obj; in [A] then ...; in [a, *] then ... end`.  In that case, we also need at least one padding value.  It will be completely ignored other than its affect on the array's size, so it can be anything, e.g. `nil` or `:deconstruct_padding`.  We can request that the padding is *always* added, or we can send a bool when we really need it.  I'd favor sending the bool, just to *remind* people it's needed.  I know I'd forget one day.

So I think the following signature would be sufficient for both short-circuiting and fetching everything necessary into the smallest possible array:

```ruby
def deconstruct: () -> Array # no min, no max, return everything
               # must return all, but may short-circuit if size<min || max<size
               | (Integer min, Integer? max) -> Array?
               # may return array with only pre and post, w/o rest (maybe +1)
               | (Integer min, boolean pad, Integer pre, Integer post) -> Array?
```

And some examples (For simplicity and terseness, let's assume the following alternative patterns could also be used as multiple "case in" clauses.  So, e.g. order and identifying the "winner" matters.):
```ruby
# contains pre and/or post args, rest-arg is unbound, and "plus one" is unnecessary for disambiguation
obj.deconstruct(3, false, 2, 1) in [1, 2, *, 3]
obj.deconstruct(3, false, 3, 0) in [A, B, C, *]
obj.deconstruct(3, false, 3, 3) in [A, B, C, *] | [*, X, Y, Z]
obj.deconstruct(6, false, 3, 3) in [A, B, C, *, X, Y, Z]
# rest-arg is unbound, but an extra "plus one" entry is necessary for disambiguation
obj.deconstruct(0, true,  1, 0) in [] | [person] | [*] # silly example, I know.
obj.deconstruct(1, true,  3, 1) in [a, b, c] | [A, *, Z] | [A, *]
obj.deconstruct(4, true,  4, 4) in [A, B, C, D, *] |
                                   [A, B, C, *, Z] |
                                   [A, B, *, Y, Z] |
                                   [A, *, X, Y, Z] |
                                   [*, W, X, Y, Z] |
                                   [a, b, y, z]
obj.deconstruct(6, true,  6, 3) in [A, B, C, X, Y, Z] | [A, B, C, *, X, Y, Z]
obj.deconstruct(3, true,  3, 3) in [A, B, C] | [*, X, Y, Z]
```

I've actually been thinking about this ticket on-and-off for the last week or so...
I wrote a *much* larger response, and I've been struggling to edit it to something reasonable! :)
Anyway, I came up with a different approach for you to consider, which I'll post next.  I hope you'll find it simple, extensible, and very ruby-ish. :)

----------------------------------------
Feature #18773: deconstruct to receive a range
https://bugs.ruby-lang.org/issues/18773#change-98273

* 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>