One handy feature is that when you say $s =~ s/re/expr/ge within expr, $s will be the original $s and the offsets in @- and @+ will be offsets into the original $s, even if earlier matches changed the length of $s.

Would be nice if $& (and the vaporware @&) were usable in the substitution part of s/// without penalty...

Wow, I learn something new about perl every day.

from perlvar:

    After a match against some variable $var:

$` is the same as substr($var, 0, $-[0])
$& is the same as substr($var, $-[0], $+[0] - $-[0])
$' is the same as substr($var, $+[0])
$1 is the same as substr($var, $-[1], $+[1] - $-[1])
$2 is the same as substr($var, $-[2], $+[2] - $-[2])
$3 is the same as substr $var, $-[3], $+[3] - $-[3])
[download]

so I wrote a test case:

use strict;
for    my $regex (qr/(.)oo(.)ar(.)az/, qr/fo(.)barba(.)/) {
    my $str = "foobarbaz";
    $str =~ s/$regex/
        my @a;
        for my $index (1 .. $#+) {
            push @a, substr($str, $-[$index], $+[$index] - $-[$index])
+;
        }
        join "," , @a;
    /e;
    print "$str\n";
}
[download]

outputs

f,b,b
o,z
[download]

I'll have to remmember that one.

--

flounder

And now in the usual idiom as well.

join
    "," ,
    map
        substr( $str, $-[$_], $+[$_] - $-[$_] ),
        1 .. $#+;
[download]

When you do a simple match, you can assign the captured portions to an array like this:

my $str = "foobarbaz";
my @a = $str =~ /(.)oo(.)ar(.)az/;
local $, = ", ";
print @a;

__OUTPUT__
f, b, b
[download]

Given that, you can wrap the match in a qr// and run it twice:

my $regex = qr/(.)oo(.)ar(.)az/;
my $str = "foobarbaz";
my @a = $str =~ $regex;
$str =~ s/$regex/$3$2$1/;
local $, = ", ";
print $str, @a;

__OUTPUT__
bbf, f, b, b
[download]

You can use the code assertion regex to do this. (See perlre "Extended patterns" for details).

P:\test>perl -Mstrict -wle"
    my $s = 'the quick brown fox jumps over the lazy dog';
   my @bits; 
   $s =~ s[
        .(.)(?{ push@bits,$^N })
        ..(..)(?{ push@bits,$^N })
        .]
   [ print join'-',@bits; ]gex;"

h-qu
h-qu-k-ro
h-qu-k-ro- -x
h-qu-k-ro- -x -m- o
h-qu-k-ro- -x -m- o-r-he
h-qu-k-ro- -x -m- o-r-he-a- d
[download]

Note: I've split the 'one-liner' up to avoid the code wrap mangler.

This just might be the excuse I was looking for to use the (?{}) construct and friends. But I notice that perlre says...

WARNING: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice.

But there is nary a word about this experimentalism in my 3rd edition Camel. Anyone care to take a guess about its life expectancy? (5.10?, ponie?, 6.0?)

There may (should) be change in how those constructs interact with lexicals in the code. Otherwise, they aren't going away in any version of perl5.