Re^2: Why does each() always re-evaluate its argument? (Updated x2 - experimental "for_list" )

[eyepopslikeamosquito]

> You may rather want to take a look at this newer (5.36 experimental) syntax: use experimental "for_list";

Just an FYI, in Re^7: Rosetta Code: Long List is Long (Updated Solutions - short Perl GRT and for_list), I excitedly changed one line from:

while (my ($k, $v) = each %{$href}) { push @lines, pack('NA*', -$v, "$
+k\t$v") }

to:

for my ($k, $v) (%{$href}) { push @lines, pack('NA*', -$v, "$k\t$v") }

and it produced the identical result ... but, sadly, did not run appreciably faster.

[LanX]

> but, sadly, did not run appreciably faster

experimental "for_list" solves so many issues of each , that I'm already very happy if it's not slower.

It's elegant, orthogonal and intuitive, and I hope the experimental phase will be a success.

This benchmarks claims it to be much faster, but we all know how tough it is to write reasonable benchmarks which don't compare apples with oranges.

Actually I'm surprised that copying large hashes into a list can even compete with the built-in iterator-counter of perl hashes used by 'each'.

The implemention must be very clever. Or the overhead will only show with much larger hashes.

[ikegami]

Actually I'm surprised that copying large hashes into a list can compete with the built-in iterator of perl hashes.

1) There's no copying, and 2) it uses the built-in iterator.

When we say "returns a list", we simply mean "returns zero or more scalars". It's not a data structure. You don't copy into a list since there's no such thing. We're talking about pushing pointers onto the stack. Which is exactly what keys, each or any other approach would have to do as well. There's no extra work here, so it shouldn't be surprising that it's not any slower.

[LanX]

> 1) There's no copying,

If that's so, then the docs should be clearer:

# The hash is immediately copied to a flat list before the loop starts.

> 2) it uses the built-in iterator.

In that case, I suppose nested loops over the same hash are covered by saving and restoring the localized iterator?

I was expecting a more intelligent solution than literally "copying to a flat list" but this also leads to another question:

What happens if the hash is altered inside the loop, if it's not copied "before the loop starts"