Issue #1873 has been updated by naruse (Yui NARUSE).


erikh (Erik Hollensbe) wrote:
> I've attached a new patch -- this implements the same functionality but refers to it as `all_values` and reverts the old changes to `values_at`. This is fundamentally the same functionality as `values_at` with the overridden functionality described in the ticket.

I don't think all_values is a good name.
Your implementation is good for making the feature clear.

mame says
> I expect values_at returns an array whose length is equal to the number of arguments.

I agree this.
This depends usual question; what is the use case?

> Tests pass, including the new ones.

Adding tests is good contribution, but this doesn't cover the feature.
Anyway, how it should behave depends on use case.
I'm considering more simple API to get the array of strings which are captured by a group,
but it also needs the use case.


boris_stitnicky (Boris Stitnicky) wrote:
> Hi everyone. I am a newbie user of computer languages (< 1 year), and I am
> providing my feedback from this position.

Regexp is not for newbies, but for well-trained programers.

> Summary:
> I find that this feature proposal is basically an extension of Regex state
> machine functionality. I am against it. I think, that the current behavior
> is natural: When one uses the same capture group name again, the old value
> is lost, just like when one assigns a new value to the same variable name.
> In Regex machine, I value simplicity and memorizeability over abundance of
> features. Moreover, as runpaint points out himself, this feature is really
> not missing: "lost" captures are available via #to_a and #capture methods.

As you can see through the patch, Oniguruma, the regexp engine of Ruby 1.9,
doesn't lost the old value.

> Rationale:
> As a newbie, I still remember hard time that I had learning Regex. I find
> the learning overhead for Ruby acceptable to make it usefull as a tool for
> people, who are not programmers by profession. But I found that to actually
> solve even simple domain-specific programming tasks, one has to also learn
> seemingly endless list of formats, sub-standards, sub-languages, programers'
> editors and other idiosyncrasies, which in total take much greater effort
> that learning Ruby itself. Regex is one of these sub-languages.

Ruby won't reject a new feature because it is difficult for a newbie,
because Ruby belives a newbie shall be a professional.
Ruby won't barrier the growth of programmers.

> The idea of a simple state machine that performs matching tasks far beyond
> find & replace comes as very natural to me. I might have learned Regex in
> 1 hour in good old days when it only had 25 features. But today, Regex has
> (lemme count) 8 anchors, 9 character classes, 8 assertions, 10 quantifiers,
> 9 backreferences, 10 range syntaxes, 7 pattern modifiers, 14 metacharacters,
> passive/active, greedy/ungreedy concept, in total, roughly 75 symbols and
> concepts to confuse one's head. Old dog programmers who have been with Regex
> throughout its history might not be noticing this, but for newbies, who have
> to memorize whole Regex machine in one fell swoop, is is already very hard
> to learn. I think that with the number of features that Regex already has,
> adding more causes disproportionate growth in learning overhead for newbies.

You haven't see the delight of regular expression.
----------------------------------------
Feature #1873: MatchData#[]: Omits All But Last Captures Corresponding to the Same Named Group
https://bugs.ruby-lang.org/issues/1873#change-27889

Author: runpaint (Run Paint Run Run)
Status: Feedback
Priority: Normal
Assignee: naruse (Yui NARUSE)
Category: core
Target version: 2.0.0


=begin
 I suspect that MatchData#[:symbol] should return an Array of values when the same named group has been matched multiple times.
 
   >> m = 'food'.match(/(?<f>oo)(?<f>d)/)
   => #<MatchData "ood" f:"oo" f:"d">
   >> m[:f]
   => "d"
   >> m.to_a
   => ["ood", "oo", "d"]
=end



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