A hint of what is going on:

use warnings;
use strict;
use Data::Dumper;

gf();
gf();

sub gf
{
    my $ins1 = '4 A -4 C -4 B 1 D';
    my @inserts;
    print "\nat the beginning: " . \@inserts . "\n";
    print $ins1, "\n";
    $ins1 =~ /[\d+-]+(?: \w ([\d+-]+)(?{print \@inserts, "\n"; push @i
+nserts, $1}))*/g;
    print "\n" . join ' ', @inserts;
}
[download]

This prints:

at the beginning: ARRAY(0x189126c)
4 A -4 C -4 B 1 D
ARRAY(0x189126c)
ARRAY(0x189126c)
ARRAY(0x189126c)

-4 -4 1
at the beginning: ARRAY(0x224fc8)
4 A -4 C -4 B 1 D
ARRAY(0x189126c)
ARRAY(0x189126c)
ARRAY(0x189126c)
[download]

The push for the second pass pushed everything into the first array.

use warnings;
use strict;

gf ();
gf ();

sub gf
{
    my $ins1 = '4 A -4 C -4 B 1 D';
    our @inserts = ();
    $ins1 =~ /[\d+-]+(?: \w ([\d+-]+)(?{push @inserts, $1}))*/g;
    print "\n" . join ' ', @inserts;
}
[download]

You are right. The binding was resolved at compiling time. There was a deep binding of @inserts inside that anonymous subroutine. That binding lasts beyond the scope of @inserts.

Note that you can also work around it by declaring a lexical outside the scope of the sub:

{
    my @inserts;
    sub gf
    {
        @inserts = ();
        my $ins1 = '4 A -4 C -4 B 1 D';
        print "\nat the beginning: " . \@inserts . "\n";
        print $ins1, "\n";
        my $re = qr/[\d+-]+(?: \w ([\d+-]+)(?{print \@inserts, "\n"; p
+ush @inserts, $1}))*/;
        $ins1 =~ /$re/g;
        print "\n" . join ' ', @inserts;
    }
}
[download]

You might notice that I created a regex variable. I had hoped that that would cause the regex to be bound at runtime, but no such luck. Creating an empty variable and inserting it in the regex does force runtime evaluation (at least inasmuch as it demands use of use re 'eval'), but it still doesn't make the (?{}) section use the current incarnation of @inserts.

---

Caution: Contents may have been coded under pressure.

As pg demonstrates, you have created an inadvertent closure. This issue has come up before. I'm wondering if it might be appropriate for perl to issue a warning here. It can be a nasty bug.

-sauoq
"My two cents aren't worth a dime.";

Fully agree with you and there better be a warning.

Closure was meant to be a feature, so that people can use it when they need it (and they KNOW that they are using it). But so often people just get trapped without knowing that there is a closure in their code, and it becomes very tricky to application programmers.

A warning in this case will be very helpful.

dave_the_m has been working on the closure code so its quite possible this warns in blead. I know he has made improvements in that area.

---
$world=~s/war/peace/g

And you probably have this already if you're benchmarking, but I suspect /g probably is the right way to go:

use warnings;
use strict;

gf ();
gf ();

sub gf
{
    my $ins1 = '4 A -4 C -4 B 1 D';
    my @inserts;
    $ins1 =~ /^[\d+-]+/g;
    push @inserts, $ins1 =~ /\G(?: \w ([\d+-]+))/g;
    print join(' ', @inserts), "\n";
}
[download]

Result of evolving code I suspect. Think of it as an appendix - most of the time it does no harm, but it has no obvious use. :)

---

Perl is Huffman encoded by design.