Yup! That's essentially the solution I arrived at here, although the \G in your version isn't doing anything in this case. I believe (but am open to correction) that \G doesn't have any effect unless you also use the /c modifier and even then, it only has an effect once a failure has occurred in which case, a subsequent match on the same target string will start from the point of the previous failure.

The reason for wanting the capturing group withing a repeat count to work in the way I described was that it would allow the s/// used in the above reference to only effect the substitution on the target string if the format of the target string exactly matched the regex.

Your regex will happily match 'ff:ff' or 'ff:ff:ff:ff:ff:ff:ff:ff:ff:' as you are aware, which is why you are checking the size of the array afterwards. Thats ok, but in the case where you want to modify the target using the s/// operator, it forces you to match & capture, test and then modify *IF* the number of matches is correct

my $mac = 'ff:ff:ff:ff:ff:ff';
if (6 == ($_ = () = $mac =~ /([0-9A-Z]{1,2})(?::|$)/ig) ){ 
    $mac =~ s/([0-9A-Z]{1,2})(?::|$)/ substr "0$1", -2 /ieg;
}
[download]

in order that you ensure that you only modify the target if it actually conforms to the required format.

That makes for a hell of a lot more work, redundancy, needless capturing and duplication than it would if the repeat group repeated the capture group as well.

It might then look like this:

my $mac = 'ff:ff:ff:ff:ff:ff';
$mac =~ s[^ (?: ( [0-9A-Z]{1,2} ) : ){5} ( [0-9A-Z]{1,2} ) $] 
         [ sprintf '%02s' x 6, $1, $2, $3, $4, $5, $6 ]iex;
[download]

No need for the redundant capturing, duplicated matching, nor even to test as the substitution will only occur if the target matches the pattern exactly.

I think that John M. Dlugosz hit the nail on the head. The best way of acheive my aim is to use the x operator to build the regex then compile it with qr// like this.

my $re_mac = '(?: ( [0-9A-Z]{1,2} ) : )' x 5 . '( [0-9A-Z]{1,2} )';
$re_mac = qr[$re_mac]ix;
....

$mac =~ s[^ $re_mac $] [ sprintf '%02s' x 6, $1, $2, $3, $4, $5, $6 ]e
+x;
[download]

That satisfies my desire to avoid redundancy whilst only performing the substitution if the tightly specified regex is matched exactly. If I need to know whether the substitution occured, I can simply test its return.

The main reason for the SoPW was simply that this was the first time I had ever tried to apply a repeat count to a capture group and when it didn't work the way my instincts told me it would, I tried to look up the description that explained the behaviour, and came up short. I'm still not entirely convinced that the passage that Arien cites is an explanation for the behaviour. Given the context of the passage, it seems entirely disparate from the usage I am describing. However, if it was in the authors mind to cover both situations in that short passage, then I think this is a case where a few more words, or perhaps a second short paragraph to seperate and clarify the two would have benefited.