I'm matching a sequence of a repeating arbitrary character, with a minimum length, using a perl6 regex.

After reading through https://docs.perl6.org/language/regexes#Capture_numbers and tweaking the example given, I've come up with this code using an 'external variable':

#uses an additional variable $c
perl6 -e '$_="bbaaaaawer"; /((.) :my $c=$0; ($c)**2..*)/ && print $0';

#Output: aaaaa

To aid in illustrating my question only, a similar regex in perl5:

#No additional variable needed
perl -e ' $_="bbaaaaawer"; /((.)22,)/ && print $1';

Could someone enlighten me on the need/benefit of 'saving' $0 into $c and the requirement of the empty ? Is there an alternative (better/golfed) perl6 regex that will match?

Thanks in advance.

Omitting the capture around the $0 works:

$_="bbaaaaawer"; / (.) $0**2..* / && print $/; # aaaaa

(And then you can also omit the .)

But perhaps you wrote the capture around the $0 for a good reason.

Perhaps you want a way to be able to count the number of repeats. If so, you could instead write:

$_="bbaaaaawer";
/ (.) $0**2..* /;
print $/.chars div $0.chars; # 5

Job done, and without unnecessary complications.

But maybe you really need to have a pattern that must be captured and must include a copy of whatever was matched by an earlier pattern. In that case I think you have the golf'dest solution and all that's left is to explain why the various things you mention are necessary.

First, you have to take into account that matches are nested. Once you type parens, you've inserted a new level in a tree. Second, you have to take into account that the automatically generated match names like $0 refer to matches within the current level of the tree. See jnthn's answer for why and Brad's for further discussion.

What I'll add to those is an analogy to filesystem paths. If one compares a parse tree with a filesystem, P6 makes it easy to refer to the current directory and its sub-directories but does not include the equivalent of specifying the root directory or the .. parent directory and its parents.

In the following, it's easy to display 'bc' or 'c' with a code block inserted at the second level of parens:

$_="abc";
print m/ ( ( . ) ( . ( . ) print $/, $0 ) ) /; # bcc

The $/ in the code block refers to "the current match object". Directly inside the second level of parens the current match object corresponds to the second level of parens, which capture 'bc'.

The $0 at the same level refers to the first inner parens of the second level, i.e. the third level that capture 'c'.

But there's no built in way to refer to the captured 'a', or the full 'abc' capture, from that code block.

Hence you have to do something like what you've done.

forces "publication" of match results thus far

The is necessary to force the :my $c=$0; to update after the first 'a' is matched. Otherwise it would be stuck on the 'b'.

Please read "Publication" of match variables by Rakudo.

Perl 6 regexes scale up to full grammars, which produce parse trees. Those parse trees are a tree of Match objects. Each capture - named or positional - is either a Match object or, if quantified, an array of Match objects.

This is in general good, but does involve making the trade-off you have observed: once you are on the inside of a nested capturing element, then you are populating a new Match object, with its own set of positional and named captures. For example, if we do:

say "abab" ~~ /((a)(b))+/

Then the result is:

｢abab｣
 0 => ｢ab｣
 0 => ｢a｣
 1 => ｢b｣
 0 => ｢ab｣
 0 => ｢a｣
 1 => ｢b｣

And we can then index:

say $0; # The array of the top-level capture, which was quantified
say $0[1]; # The second Match
say $0[1][0]; # The first Match within that Match object (the (a))

It is a departure from regex tradition, but also an important part of scaling up to larger parsing challenges.

The reason you have to store the capture into something other than $0 is that every capturing () creates a new set of numbered captures.

So the $0 inside of ($0) can never refer to anything, because you didn't set $0 inside of the ().

(The named captures $<foo> are also affected by this.)

The following has 3 separate $0 “variables”, and one $1 “variable”:

'aabbaabb' ~~ / ^ ( (.)$0 ((.)$0) ) $0 $ /

'aabbaabb' ~~ /
 ^

 # $0 = 'aabb'
 (

 # $0 = 'a'
 (.) $0

 # $1 = 'bb'
 (

 # $0 = 'b'
 (.) $0
 )
 )

 $0

 $
 /

｢aabbaabb｣
 0 => ｢aabb｣
 0 => ｢a｣
 1 => ｢bb｣
 0 => ｢b｣

Basically the () in the regex DSL act a bit like in normal Perl6.

A fairly direct if simplified translation of the above regex to “regular” Perl6 code follows.

(Pay attention to the 3 lines with my $/ = [];)

(Also the / ^ / style comments refer to the regex code for ^ and such above)

given 'aabbaabb' 
 my $/ = []; # give assignable storage for $0, $1 etc.
 my $pos = 0; # position counter
 my $init = $pos; # initial position

 # / ^ /
 fail unless $pos == 0;

 # / ( /
 $0 = do 
 my $/ = [];
 my $init = $pos;

 # / (.) $0 /
 $0 = .substr($pos,1); # / (.) /
 $pos += $0.chars;
 fail unless .substr($pos,$0.chars) eq $0; # / $0 /
 $pos += $0.chars;

 # / ( /
 $1 = do 
 my $/ = [];
 my $init = $pos;

 # / (.) $0 /
 $0 = .substr($pos,1); # / (.) /
 $pos += $0.chars;
 fail unless .substr($pos,$0.chars) eq $0; # / $0 /
 $pos += $0.chars;

 # / ) /
 # the returned value (becomes $1 in outer scope)
 .substr($init, $pos - $init)
 

 # / ) /
 # the returned value (becomes $0 in outer scope)
 .substr($init, $pos - $init)
 

 # / $0 /
 fail unless .substr($pos,$0.chars) eq $0;
 $pos += $0.chars;

 # / $ /
 fail unless $pos = .chars;

 # the returned value
 .substr($init, $pos - $init)

TLDR;

Just remove the () surrounding ($c) / ($0).

(Assuming you didn't need the capture for something else.)

/((.) $0**2..*)/

perl6 -e '$_="bbaaaaawer"; /((.) $0**2..*)/ && put $0';