[ruby-core:107565] [Ruby master Feature#18583] Pattern-matching: API for custom unpacking strategies?

["zverok (Victor Shepelev)" <noreply@ruby-lang.org>]

Issue #18583 has been updated by zverok (Victor Shepelev).


One simpler example is, that matching something with regexps with capture groups is still quite annoying!
```ruby
case string
when /{{(.+?)}}/
  content = Regexp.last_match[1] # looking into global value isn't exactly elegant, right?
```

We could've probably bend it towards
```ruby
case string
in /{{(.+?)}}/ => content # the matched group
```

This, though, raises a question of several match groups, at which point one starts to want more:
```ruby
case string
in /{{(.+?): (.+?)}}/ => [key, value]
  # use key and value
in /{{=(?<named>.+?)}}/ => {named:}
  # use named
```
...so... IDK.

----------------------------------------
Feature #18583: Pattern-matching: API for custom unpacking strategies?
https://bugs.ruby-lang.org/issues/18583#change-96478

* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
----------------------------------------
I started to think about it when discussing https://github.com/ruby/strscan/pull/30. 
The thing is, usage of StringScanner for many complicated parsers invokes some kind of branching.

In pseudocode, the "ideal API" would allow to write something like this:
```ruby
case <what next matches>
in /regexp1/ => value_that_matched
  # use value_that_matched
in /regexp2/ => value_that_matched
  # use value_that_matched
# ...
```
This seems "intuitively" that there *should* be some way of implementing it, but we fall short. We can do some StringScanner-specific matcher object which defines its own `#===` and use it with pinning:
```ruby
case scanner
in ^(Matcher.new(/regexp1/)) => value_that_matched
# ...
```
But there is no API to tell how the match result will be unpacked, just the whole `StringScanner` will be put into `value_that_matched`.

So, I thought that maybe it would be possible to define some kind of API for pattern-like objects, the method with signature like `try_match_pattern(value)`, which by default is implemented like `return value if self === value`, but can be redefined to return something different, like part of the object, or object transformed somehow.

This will open some interesting (if maybe uncanny) possibilities: not just slicing out the necessary part, but something like
```ruby
value => ^(type_caster(Integer)) => int_value
```

So... Just a discussion topic!



-- 
https://bugs.ruby-lang.org/