Welcome to The Monastery, and thank you for writing your node.

I have little experience with the Benchmark module, but after conducting some tests, I would say that you should use the latter method, the one you prefer. It is more concise, easier to read, and a little more efficient. (thanks for the notice, ikegami.)

#!/usr/bin/perl

use warnings;
use strict;
use 5.010;
use Benchmark qw(:all);
use Data::Dumper;

cmpthese(100000, {
    'LowOutside' => sub {
        my @array = qw(8 1 3 5 6 2);
        @array = sort @array;
        foreach (@array) {
            my $num = $_;
        }
    },
    
    'LowInside' => sub {
        my @array = qw(8 1 3 5 6 2);
        foreach (sort @array) {
            my $num = $_;
        }
    },
    
    'Outside' => sub {
        my @array = qw(8 1 3 5 6 2) x 100;
        @array = sort @array;
        foreach (@array) {
            my $num = $_;
        }
    },
    
    'Inside' => sub {
        my @array = qw(8 1 3 5 6 2) x 100;
        foreach (sort @array) {
            my $num = $_;
        }
    }
});

__END__
               Rate    Outside     Inside LowOutside  LowInside
Outside      1681/s         --        -1%       -99%       -99%
Inside       1691/s         1%         --       -99%       -99%
LowOutside 169492/s      9985%      9924%         --        -5%
LowInside  178571/s     10525%     10461%         5%         --
[download]

I would say that you should use the latter method, the one you prefer. It is more concise, easier to read, and a little more efficient.

1% and even 5% is within the margin or error of Benchmark, so that last phrase is inaccurate.

I'm actually surprised they're the same speed. @a = sort @a; is optimized to be done in place, and I think for (@a) is optimized over the more general for (LIST) (it's definitely implemented differently).

Both methods are practically the same in terms of speed. When you do foreach (sort @a), the foreach doesn't loop over @a but instead over the anonymous (and temporary) array that was returned from the sort function.

The only difference of the two methods is that the first method stores the (anonymous) sorted array into @a before going into the foreach loop, while the second method leaves the sorted array anonymous.

That's clear and understandable, and what I would have thought too. (</metoo> ;-)

But I am still puzzled as to what is happening in the example of

my @a = (1);
foreach (@a) { push @a, 1; }
[download]

---

Ceci n'est pas une signature

You are looping over an array you are adding to, so you are never reaching the end.

This is somewhat similar to the following loop

my $i=1; my $end= 2;
while ($i++<$end) {
  $end++;
}
[download]

Note that

y @a = (1);
foreach (sort @a) { push @a, 1; }
[download]

stops immediately, because here you are looping over the anonymous array that is not expanding.

Essentially what you are doing is something like this:

my @a = (1);

for ( my $i = 0 ; $i <= $#a ; $i++ ) {
    push( @a, 1 );
}
[download]

So the loop isn't being restarted or re-evaluated, but because you are extending the thing it's iterating over, it never gets to the end.

---

www.jasonkohles.com
We're not surrounded, we're in a target-rich environment!

I notice that the following code runs forever:

foreach (@a) { push @a, 1; print scalar @a, "\n" }
[download]

Prints:

2
3
4
5
...
[download]

I found this in the docs for Foreach Loops:

If any part of LIST is an array, foreach will get very confused if you add or remove elements within the loop body, for example with splice. So don't do that.

Now I am curious as to what perl is doing internally. Can any monks offer a deeper explanation?

Now I am curious as to what perl is doing internally. Can any monks offer a deeper explanation?

I think it iterates over the array instead of putting it on the stack. You can circumvent the optimisation by changing for (@a) to for ((),@a).

I don't know, but my guess is that perl simply keeps a pointer to the array-element it is at in the loop. I did a few tests with splice and perl did exactly what I expected from it. It looped over the array positions (!! not the array values) until it was outside the array length (because of looping or a shrinking of the array).

Would be nice if someone could show me a case where perl gets confused. I could not create one

Would be nice if someone could show me a case where perl gets confused. I could not create one

Confused by addition:

>perl -wle"@a=1; for ((),@a) { push @a,$_+1; print }"
1

>perl -wle"@a=1; for (@a) { push @a,$_+1; print }"
1
2
3
4
...
[download]

Confused by deletion:

>perl -wle"@a=(1,2); for (@a) { pop @a; print qq{<$_>} }"
<1>

>perl -wle"@a=(1,2); for ((),@a) { pop @a; print qq{<$_>} }"
<1>
Use of freed value in iteration at -e line 1.
[download]

foreach (sort @a) { ... }
[download]

In practice, iterations over a range (foreach ($x .. $y)) or an array (even one built on the fly: foreach (@{[ sort @x ]})) are optimized to not need to load the full list ahead of time. Since this optimization shouldn't introduce differences in behaviour, what you are seeing with a push in the loop is a bug.