Perl equivalent of java Iterator - perl

Question

In java for a class that represents a collection, if it implements the iterable interface, iterating over the collection can be done without any knowledge about the collection using the foreach loop.
Can we do something similar in perl? Suppose my perl class is a collection. What is the best way of iterating over the collection ?

Answer 1

If you use a Perl hash in place of a Collection, then you can use each to iterate over it.
Every call to each %hash will return the next key/value pair, or an empty list at the end.

Answer 2

Perl doesn't have Java-style iterators, cause it doesn't need them. Perl has rather robust hashes and lists built in, which supplant most custom collections you'll ever need, and you can easily loop over them already. And if you want to do something with each element (and particularly if you want to build a list of the results), there's functions like map that you can pass a code ref to.
If you really want this Java'ism, though, you could build your own iterator class. It doesn't have to implement or extend any particular interface, cause Perl duck-types -- and normal people don't use iterators anyway, so there's no standard interface in the first place. And it doesn't have anything to do with foreach. :P
Really, it's better to just use the standard collection types. I've never run into a case where i needed a custom collection.

Answer 3

You can create arbitrarily complex iterators in perl by using closures and functional programming techniques, for when you need something above and beyond perl's built in ability to iterate over arrays and hashes. Here is is simplistic example to illustrate the technique - in this instance, its pretty useless since an iterator is unnecessary for this particular case. But as I said this technique can be applied usefully in other scenarios. This example will walk over an array backwards, skipping elements that we want excluded (in this case, the letter 'c').
sub gen_iter {
my #collection = #_;
return sub {
while (my $item = pop #collection) {
next if $item eq 'c';
return $item;
}
}
}
my $it = gen_iter((qw/a b c d e f g/));
# prints 'gfedba'
while (my $item = $it->()) {
print $item;
}
I recommend grabbing the free ebook 'High-Order Perl' and digesting the chapter on iterators. It has some great, useful examples.

Answer 4

Perl's two builtin collections — arrays and hashes — have various ways to be iterated:
foreach loops: This loops (but not iterates lazily) through each item in the given list. Using this on hashes is probably wrong, you should either iterate over the values or the keys:
foreach my $key (keys %hash) {
do something;
}
The each iterator: You can iterate through "collections" with the each function. Each time it is called, it will return a list of a key/index, and a value. If no further items are there, it will return a false value:
while (my ($key, $value) = each %hash) {
do something;
}
You can only have one such iterator per array/hash. This usage of each on arrays is a rather new feature.
The each idiom can be extended via closures to create custom iterators:
my %hash = ...;
my #keys = keys %hash; # cache the current keys
my $i = 0;
my $iter = sub {
return unless $i < #keys;
my $key = $keys[$i++];
return ($key, $hash{$key});
};
...;
while (my ($key, $value) = $iter->()) {
do something;
}