Conditions in Perl loops and performance - perl

Question

There are many idioms in Perl with the using of operators/functions/subprograms/methods in loop conditions. Books advice use them!
But as I understand these conditions are calculated each iteration. Am I right?
Perl 5:
foreach my $key (keys %hash) { ... }
for my $value (values %hash) { ... }
Perl 6:
for 'words.txt'.IO.lines -> $line { ... }
while $index < $fruit.chars { ... }
Why programmers don't assign condition to some variable before loop and use this variable in loop? It would increase speed. So the first example would look like this:
my #array = keys %hash;
foreach my $keys (#array) { ... }

Answer 1

The condition is only calculated initially (before the loop starts) so I do not think it would increase the speed to precalculate the array before the loop.. Example:
for my $key (get_keys()) {
say $key;
}
sub get_keys {
say "Calculating keys..";
return qw(a b c d);
}
Output:
Calculating keys..
a
b
c
d

Answer 2

foreach my $key (keys %hash) { ... }
for my $value (values %hash) { ... }
The for and the foreach are synonymous in Perl, so aside from the fact that your two example snippets are operating on different parts of the hash, they're the same thing.
Ok, so here's what happens internally: In each case all keys, or all values are calculated as a list, and then the looping construct iterates on that calculated list. There is an internal check, but that check is only to see if the loop has reached the offset of the last element in the list yet. That is a cheap operation in the underlying C code. To be clear, keys and values are not called on each iteration. The list of things iterated over is computed only once at the beginning of the loop.
Also, $key and $value are aliases to the actual key or the actual value, not copies. So there is no per-iteration copy made.
The nuance that is often missed is the fact that the iteration list is precomputed upon entering the loop. That is why it's considered a terrible idea to do this:
foreach my $line (<$file_handle>) {...}
...because the entire file must be read and held in memory at once before the first line can be processed. The fact that a list must be available internally first is typically an acceptable memory trade-off for things that are already held in memory to begin with. But for external sources such as a file there's no guarantee that available memory can hold the whole thing -- particularly if it's some endless stream. Consider this code:
open my $fh, '<', '/dev/urandom';
say ord while <$fh>;
It will never terminate, but will emit a constant stream of ordinal values. However, it does not grow in memory usage.
Now change the second line to this:
say ord for <$fh>;
This will appear to hang while it consumes all of the system's memory attempting to retrieve the entire contents of /dev/urandom (and endless stream). It must do this before it can start iterating, because that's how a range-based foreach loop works in Perl, and some other languages.
So a range based foreach loop is inexpensive in its computational overhead, but in some cases potentially expensive in its memory footprint.
Speaking to your final example:
my #array = keys %hash;
foreach my $keys (#array) { ... }
It doesn't make an appreciable difference, and may actually be slower or consume more memory. When I compare the two approaches with a hash of 100000 elements the difference between the two is only 2%, or within the margin of error:
Rate copy direct
copy 35.9/s -- -2%
direct 36.7/s 2% --
Here's the code:
use Benchmark qw(cmpthese);
my %hash;
#hash{1..100000} = (1..100000);
sub copy {
my #array = keys %hash;
my $b = 0;
$b += $_ foreach #array;
return $b;
}
sub direct {
my $b = 0;
$b += $_ foreach keys %hash;
return $b;
}
cmpthese(-5, {
copy => \&copy,
direct => \&direct,
});