#! /usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

my @a = (a => 1, b => 2, c => 3);

sub clone_a {
    print "cloning \%a\n";
    return [@a]
}

while (my ($index, $val) = each @{ clone_a() }) {
    print "$index => $val\n";
}
[download]

Perl stores the iterator for each in the hash or array structure. As the anonymous hash/array is a different one each time, it has a different iterator.

for (or foreach for those who like to type more) just loops over a list of values. That's why you can for qw( a b c ) - no object needed to store an iterator.

Update: BTW, where's any eval anywhere?

Thanks, the "eval", of course, was a typo.

Please, fix it, so we don't confuse further readers.
map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]

Please edit and fix the title. :)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

each expects a hash (or array with "newer" perls).

The %{} does dereferencing of the enclosed expression, which needs to be evaluated.

There is no way to tell for %{} if and why the result should be cached.

Update

To elaborate further, each is not a loop construct like foreach

It's more like a method operating on the hash, with no clear entry point.

Think %hash->each() and you can call each anytime outside while.

Update

You may rather want to take a look at this newer (5.36 experimental) syntax:

use experimental "for_list";

foreach my ($key, $value) (%hash) {
    # iterate over the hash
    # The hash is immediately copied to a flat list before the loop
    # starts. The list contains copies of keys but aliases of values.
    # This is the same behaviour as for $var (%hash) {...}
}
[download]

> 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") }
[download]

to:

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

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

👁️🍾👍🦟

> 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.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

see also perl 5.36 and the for_list feature - a simple speed comparison

It's not a difference between a foreach loop and each; it's not a difference between a foreach loop and a while loop.

A foreach loop is used when we need to iterate a number of times which is known up front.

On the other hand, a while loop allows us to loop a number of times that isn't known ahead of time. An expression is repeatedly evaluated to determine if the loop should be entered again. It MUST be evaluated each time. It wouldn't work otherwise.

So why does following work:

while ( my ( $k, $v ) = each( %h ) ) {
  ...
}
[download]

Each array and hash has an iterator associated with it which is used by each, keys and values. Each call to each fetches one element from that iterator (resetting the iterator once the end is reached).

So then what about the following:

while ( my ( $k, $v ) = each( %{ create_new_hash() } ) ) {
  ...
}
[download]

A different, newly-created hash is passed to each each time. Each of those hashes has a fresh iterator. Each of those iterator returns the first element of that hash.

Giving each array and hash its own iterator allows us to use

while ( my ( $k, $v ) = each( %h ) ) {
  ...
}
[download]

instead of having to use

my $iter = get_iter( \%hash );
while ( my ( $k, $v ) = $iter->() ) {
   ...
}
[download]

What some other newer languages have done instead is provide syntactical support for iterators. The equivalent of the previous snippet is what's executed.

using ( var iter = dict.GetEnumerator() ) {
   while ( iter.MoveNext() ) {
      var entry = iter.Current;
      ...
   }
}
[download]

But a shorthand is provided by the language.

foreach ( var entry in dict ) {
   ...
}
[download]

You can build iterators in Perl, but it lacks the syntactical support shown here.